← Back to branch summary

~f-milthaler/fluidity/fsi-model-stationary-solid-with-velocity

« back to all changes in this revision

Viewing changes to schemas/adaptivity_options.rnc

  • Committer: f.milthaler10 at uk
  • Date: 2013-11-06 13:43:56 UTC
  • mfrom: (3463.184.85 fluidity)
  • Revision ID: f.milthaler10@imperial.ac.ic.uk.-20131106134356-v3lw1dheesckywj0
merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
schemas/adaptivity_options.rnc
892
892
         ## purposes. They are subject to change and may not be in the final "release".
893
893
         element zoltan_options {
894
894
            ## Select which partitioner to use during all but the last adapt iteration.
895
 
            ## Graph partitioners available are ParMETIS and Zoltan PHG. The Zoltan
896
 
            ## PHG hypergraph partitoner is also available.
897
 
            ## Default is the Zoltan PHG graph partitioner.
 
895
            ## Default is the Zoltan PHG graph partitioner which gives good results in 
 
896
            ## most situations.
898
897
            element partitioner {
899
 
                ## Use the ParMETIS graph partitioner. ParMETIS setup to match as
900
 
                ## closely as possible the setup used previously by Sam.
901
 
                element metis {
902
 
                    empty
903
 
                }|
904
 
                ## Use the PT-Scotch graph partitioner.
905
 
                element scotch {
906
 
                    empty
907
 
                }|
908
 
                ## Use the Zoltan PHG partitioner.
909
 
                element zoltan {
910
 
                    ## Select the partitioning method you would like used by Zoltan PHG.
911
 
                    ## Currently hypergraph partitioning is the simplest implementation
912
 
                    ## and can produce non-contiguous partitions for certain problems.
913
 
                    element method {
914
 
                    "graph"|"hypergraph"
915
 
                    }
916
 
                }
 
898
               (
 
899
                  ## Use the Zoltan PHG partitioner (recommended).
 
900
                  element zoltan {
 
901
                     ## Select the partitioning method you would like used by Zoltan PHG.
 
902
                     ## For intermediate partitioning we recommend using 'graph' as 'hypergraph'
 
903
                     ## ignores edge weighting.
 
904
                     element method {
 
905
                        "graph"|"hypergraph"
 
906
                     }
 
907
                  }|
 
908
                  ## Use the ParMETIS graph partitioner. ParMETIS setup to match as
 
909
                  ## closely as possible the setup used previously by Sam.
 
910
                  element metis {
 
911
                     empty
 
912
                  }|
 
913
                  ## Use the PT-Scotch graph partitioner.
 
914
                  element scotch {
 
915
                     empty
 
916
                  }
 
917
               ),
 
918
               ## Choose whether to repartition or partition the mesh at each adapt iteration.
 
919
               ## Repartitioning results in a smaller amount of data migration between processes
 
920
               ## and hence is cheaper. The default option is
 
921
               ## to repartition the mesh each iteration and then fully partition the mesh on the 
 
922
               ## final iteration to create a well balanced mesh.
 
923
               element lb_approach {
 
924
                  "REPARTITION"|"PARTITION"
 
925
               }?
917
926
            }?,
918
927
            ## Select which partitioner to use after the final adapt iteration.
919
 
            ## Graph partitioners available are ParMETIS and Zoltan PHG. The 
920
 
            ## Zoltan PHG hypergraph partitoner is also available.
921
 
            ## Default is the ParMETIS graph partitioner.
 
928
            ## Default is the Zoltan PHG hypergraph partitioner which gives good results in most 
 
929
            ## situations.
922
930
            element final_partitioner {
923
 
                ## Use the ParMETIS graph partitioner. ParMETIS setup to match as
924
 
                ## closely as possible the setup used previously by Sam.
925
 
                element metis {
926
 
                    empty
927
 
                }|
928
 
                ## Use the PT-Scotch graph partitioner.
929
 
                element scotch {
930
 
                    empty
931
 
                }|
932
 
                ## Use the Zoltan PHG partitioner.
933
 
                element zoltan {
934
 
                    ## Select the partitioning method you would like used by Zoltan PHG.
935
 
                    ## Currently hypergraph partitioning is the simplest implementation
936
 
                    ## and can produce non-contiguous partitions for certain problems.
937
 
                    element method {
938
 
                    "graph"|"hypergraph"
939
 
                    }
940
 
                }
 
931
               (
 
932
                  ## Use the Zoltan PHG partitioner (recommended).
 
933
                  element zoltan {
 
934
                     ## Select the partitioning method you would like used by Zoltan PHG.
 
935
                     ## For final partitioning we recommend using 'hypergraph' which ignores edge 
 
936
                     ## weighting but can produce very well balanced partitions.
 
937
                     element method {
 
938
                        "graph"|"hypergraph"
 
939
                     }
 
940
                  }|
 
941
                  ## Use the ParMETIS graph partitioner. ParMETIS setup to match as
 
942
                  ## closely as possible the setup used previously by Sam.
 
943
                  element metis {
 
944
                     empty
 
945
                  }|
 
946
                  ## Use the PT-Scotch graph partitioner.
 
947
                  element scotch {
 
948
                     empty
 
949
                  }
 
950
               ),
 
951
               ## Choose whether to repartition or partition the mesh at each the final adapt iteration.
 
952
               ## Repartitioning results in a smaller amount of data migration between processes
 
953
               ## and hence is cheaper. The default option is
 
954
               ## to repartition the mesh each iteration and then fully partition the mesh on the 
 
955
               ## final iteration to create a well balanced mesh.
 
956
               element lb_approach {
 
957
                  "PARTITION"|"REPARTITION"
 
958
               }?
941
959
            }?,
942
960
            ## Element quality cut off. 
943
961
            ## Elements with a quality greater than this will be liable to be
944
962
            ## on the parition boundary. Below this, they will be free to be adapted
945
 
            ## and improved. Range is 0 to 1, with default 0.6
 
963
            ## and improved. Range is 0 to 1, with default 0.1.
946
964
            ## This should be set to the same value as used for the quality option
947
 
            ## in libmba2d or libmba3d
 
965
            ## in libmba2d or libmba3d if using these libraries.
948
966
            element element_quality_cutoff {
949
967
                real
950
968
            }?,
953
971
            ## The imbalance is computed as the maximum load divided by the average load.
954
972
            ## A value for load_imbalance_tol of 1.2 indicates that 20% imbalance is okay.
955
973
            ## A high value for this parameter (~1.5) could see Zoltan produce poorer partitions
956
 
            ## but be able to move the partition boundaries easier to allow adaption. For some 
957
 
            ## problems where the partitioner creates empty partitions lowering this (~1.075) will
958
 
            ## force Zoltan to create more evenly balanced partitions (no empty ones) but may
959
 
            ## require more adapt iterations to produce a fully adapted final mesh.
 
974
            ## but be able to move the partition boundaries easier to allow adaption. 
 
975
            ## The default value is 1.5.
960
976
            element load_imbalance_tolerance {
961
977
                real
962
978
            }?,
 
979
            ## Final load imbalance tolerance.
 
980
            ## The amount of load imbalance the partitioning algorithm should deem acceptable on the 
 
981
            ## final adapt iteration. It is assumed that the mesh is well adapted by the final partition
 
982
            ## and hence we no longer worry about locked nodes. The aim is to achieve a well balanced partition.
 
983
            ## A low value is recommended. The default value is 1.03.
 
984
            element final_partition_load_imbalance_tolerance {
 
985
                real
 
986
            }?,
 
987
            ## Uncuttable edge fraction.
 
988
            ## The fraction of edges that are marked as uncuttable when partitioning with edge weighting. i.e. 
 
989
            ## all but the final adapt. This value determines the range of edge weight values that are defined 
 
990
            ## as being uncuttable, as a percentage of the worst value.
 
991
            ## Uncuttable elements are marked to allow elements with low element 
 
992
            ## qualities, when measured against the metric, to adapt. Marking more elements uncuttable may allow the mesh 
 
993
            ## to improve more quickly if Zoltan is capable of avoiding all of the edges, but could cause 
 
994
            ## Zoltan to lock edges for many adapts due to too many elements being uncuttable. The default value is 0.10
 
995
            element uncuttable_edge_fraction {
 
996
                real
 
997
            }?,
 
998
            ## Search levels for worst element quality.
 
999
            ## Number of levels of element connections to search through for element quality when setting the edge weights for partitioning. default is 2 and works fine for most situations.
 
1000
            element worst_ele_search_levels {
 
1001
                integer
 
1002
            }?,
963
1003
            ## Additional adapt iterations.
964
1004
            ## Zoltan returns the minimum element quality to adaptivity. By setting additional adapt
965
1005
            ## iterations to a value greater than zero we allow Zoltan to do adapt_iterations plus
974
1014
            ## weight mesh partitions, based upon a prescribed scalar field. 
975
1015
            ## Note that the field should have a minimum value of 0 and a maximum
976
1016
            ## value of 1 (no normalisation is done within the code).
977
 
                element scalar_field {
 
1017
            element scalar_field {
978
1018
                  attribute rank { "0" },
979
1019
                  attribute name { "FieldWeightedPartitionValues" },
980
1020
                  element prescribed {
1042
1082
               ## One dump file is created for each rank.
1043
1083
               element dump_field_sizes {
1044
1084
                  empty
 
1085
               }?,
 
1086
               ## Call LB_EVAL and print output.
 
1087
               ## This prints statistics such on the load balance achieved, and the sum of cut edges
 
1088
               ## and weighted cut edges. It also details the settings used by the partitioner.
 
1089
               element lb_eval {
 
1090
                  empty
1045
1091
               }?
1046
1092
            }?
1047
1093
         }?,
1634
1680
      continuous_discontinuous_projection,
1635
1681
      supermesh_free?,
1636
1682
      supermesh_conservation?,
1637
 
      galerkin_projection_honour_strong_bcs?
 
1683
      galerkin_projection_honour_strong_bcs?,
 
1684
      surface_projection?
1638
1685
    )
1639
1686
 
1640
1687
galerkin_projection_scalar =
1642
1689
      continuous_discontinuous_projection,
1643
1690
      supermesh_free?,
1644
1691
      supermesh_conservation?,
1645
 
      galerkin_projection_honour_strong_bcs?
 
1692
      galerkin_projection_honour_strong_bcs?,
 
1693
      surface_projection?
1646
1694
    )
1647
1695
 
1648
1696
continuous_projection =
1717
1765
                real
1718
1766
              }?
1719
1767
            }?
1720
 
          }|
1721
 
          ## Use a bounded Galerkin projection. Conservative, bounded in the
1722
 
          ## limit, and hopefully minimally dissipative. This algorithm starts with the
1723
 
          ## Galerkin projection and uses the optimisation library Algencan to bound
1724
 
          ## it by minimising a functional within constraints on boundedness and conservation.
1725
 
          ## Note well: this only works for linear fields.
1726
 
          element bounded {
1727
 
            attribute name {"Algencan"},
1728
 
            (
1729
 
              element functional {
1730
 
                attribute name {"L2"},
1731
 
                element weight {
1732
 
                  real
1733
 
                }?
1734
 
              }|
1735
 
              element functional {
1736
 
                attribute name {"LumpedMassL2"},
1737
 
                element weight {
1738
 
                  real
1739
 
                }?
1740
 
              }|
1741
 
              element functional {
1742
 
                attribute name {"IntegralL2"},
1743
 
                element weight {
1744
 
                  real
1745
 
                }?
1746
 
              }|
1747
 
              element functional {
1748
 
                attribute name { string },
1749
 
                element weight {
1750
 
                  real
1751
 
                }?
1752
 
              }
1753
 
            ),
1754
 
            ## If the bounds on this field are known then they can be set here.
1755
 
            ## These can either further constrain the limits worked out by the
1756
 
            ## lumped version of the projection (i.e. to make sure that errors 
1757
 
            ## don't accumulate with succesive interpolations) or if apply_globally
1758
 
            ## is set they are just made to be bounded within the bounds globally
1759
 
            ## (i.e. anything between those bounds is not smoothed).
1760
 
            element bounds {
1761
 
              element upper_bound {
1762
 
                real,
1763
 
                ## If this is set the upper_bound is used everywhere.
1764
 
                ## If left unset the upper_bound is only used to constrain
1765
 
                ## the smoothed bounds calculated by the code
1766
 
                element apply_globally {
1767
 
                  empty
1768
 
                }?,
1769
 
                ## This field is to be considered as being coupled to another field
1770
 
                ## such that the sum of the two fields is constrained to be less than
1771
 
                ## the upper_bound specified above.
1772
 
                ## 
1773
 
                ## The relationships between fields are worked out according to their
1774
 
                ## priority ordering.
1775
 
                ##
1776
 
                ## This method is akin to the coupled_cv advection method.
1777
 
                element coupled {
1778
 
                  empty
1779
 
                }?
1780
 
              }?,
1781
 
              element lower_bound {
1782
 
                real,
1783
 
                ## If this is set the upper_bound is used everywhere.
1784
 
                ## If left unset the upper_bound is only used to constrain
1785
 
                ## the smoothed bounds calculated by the code
1786
 
                element apply_globally {
1787
 
                  empty
1788
 
                }?
1789
 
              }?
1790
 
            }?
1791
1768
          }
1792
1769
        )?,
1793
1770
        (
1860
1837
        }?
1861
1838
      }
1862
1839
 
 
1840
surface_projection =
 
1841
      ## Remap this field to the boundary surfaces before projecting. This is only intended for fields 
 
1842
      ## where values are non-zero only on the surfaces and you want this to remain so during projection. 
 
1843
      ## Any interior values will become zero. This will also only work if the boundaries do not move.
 
1844
      element surface_projection {
 
1845
         element surface_ids {
 
1846
            integer_vector
 
1847
         }?
 
1848
      }
 
1849
 
1863
1850
mesh_adaptivity_options =
1864
1851
   element mesh_adaptivity {
1865
1852
      ## Options involving mesh movement (Lagrangian, ALE methods)