pw:: DatabaseMesher

The database mesher mode type

Derives From

Notes

This mode is used to create grid entities on database entities.

Unlike other modes, the state of the mode is saved when it is ended and subsequent modes will be created with the same state. This state is also saved in the application project file, so a new mode created after a file is loaded will have the same state as the last mode ended before saving the file.

To create a mode of this type, use the pw::Application.begin command with the mode DatabaseMesher specified, like this:

set mesher [pw::Application begin DatabaseMesher $models]

Summary

pw:: DatabaseMesher	The database mesher mode type
Instance Attributes
MergeTolerance	This attribute is the tolerance to use when merging connectors.
MinimumSpacingMode	This attribute is the preferred method for setting the minimum spacing.
MinimumBoundarySubdivisions	This attribute is the minimum number of mesh subdivisions per database boundary.
MinimumEdgeSpacing	This attribute is the minimum edge spacing for the mesh.
MinimumSubdivisionLength	This attribute is the minimum edge subdivision length in the mesh.
MinimumRadiusOfCurvature	This attribute is the minimum radius of surface curvature to use when resolving curvature along an edge in the mesh.
MaximumSpacingMode	This attribute is the preferred method for setting the maximum spacing.
MaximumExtentsSubdivisions	This attribute is the maximum number of mesh subdivisions per the extents of the entities being meshed.
MaximumEdgeSpacing	This attribute is the maximum edge spacing for the mesh.
CurvatureResolutionAngle	This attribute is the curvature angle resolution in degrees.
MaximumAspectRatio	This attribute specifies the maximum aspect ratio.
BoundaryGrowthRate	This attribute specifies the boundary growth rate.
DomainAlgorithm	This attribute determines the algorithm to use when meshing domains.
RefinementFactor	This attribute is the refinement factor used to globally scale the parameters of the mesher in order to increase the refinement.
MappedSurfaceSubdivisionRatio	This attribute is the ratio between the number of subdivisions used to detect domains that can be initialized from structured domains.
BoundaryProximityInfluence	This attribute controls how nearby boundaries influence clustering on a surface.
BoundaryGapSubdivisions	This attribute is the target number of mesh subdivisions across gaps between boundaries of the entities being meshed.
StretchingBuffer	This attribute is the target number of buffer subdivisions when TRex stretching reaches the median between boundaries of the entities being meshed.
BoundaryGroupAngle	This attribute is the turning angle to use when grouping boundaries.
BoundaryCurvatureRatio	This attribute is the ratio between the surface and curve curvature along a boundary to use when detecting Curvature boundaries.
BoundaryHardAngle	This attribute is the angle between normals to use when detecting Convex and Concave manifold boundaries.
DomainAreaRatioThreshold	This attribute is the metric threshold for domain area ratio.
DomainAspectRatioThreshold	This attribute is the metric threshold for domain aspect ratio.
DomainMaximumAngleThreshold	This attribute is the metric threshold for domain maximum angle.
KeepExistingDomains	This attribute controls whether any pre-existing domains constrained to the quilts in the mode are retained or destroyed.
SplitConnectorsAtAlignSources	This attribute controls whether connectors should be split where they intersect or come within Node tolerance of souce curves on the database being meshed.
Instance Actions
getExtents	This action gets the extents of the models of the mode.
getThinSurfaceQuilts	This action gets the quilts that are detected as thin surfaces, such as a blunt trailing edge of a wing.
getMinimumBoundaryGroup	This action gets the quilt boundary group with the minimum length.
getMinimumBoundaryGroupLength	This action gets the length of the minimum boundary group.
getSymmetryLoops	This action gets a list of symmetry loops, where each loop is a list of quilt boundaries that are lamina and lie on a symmetry plane.
getLaminaBoundaryGroups	This action gets a list of lamina quilt boundary lists of a certain classification.
getManifoldBoundaryGroups	This action gets a list of manifold quilt boundary lists of a certain classification.
createGridEntities	This action creates grid entities on the database entities of this mode.
getRejectedEntities	This action gets a list of database entities that a surface mesh was not able to be constructed on during the <createSurfaceMesh> action.
getExistingDomains	This action gets a list of domains that are dependent upon the quilts included in the mode.
getExistingSources	This action gets a list of sources that are dependent upon the quilts included in the mode.
getFilterTypes	This action returns a list of supported filter type names.
addFilter	This action adds a new, mesher mode filter to a filter queue.
deleteFilter	This action deletes a filter.
setFilterName	This action renames a filter.
getFilterNames	This action returns a list of filter names defined in the mesher mode filter_type.
getFilterCount	This action returns the number of filters of the given filter_type defined in the mesher mode.
getFilterDefinition	This action gets the definition of a filter identified by index or name.
getFilterDefinitions	This action gets a list of all filter definitions of the given filter_type.
getFilterEntityCounts	This action matches the name of each mode entity against the filter patterns in filter priority order and returns the match count for each filter.
setFilterPriority	This action sets the priority of one or more existing filters.
setFilterPatterns	This action sets the patterns of an existing filter.
setFilterEntities	This action modifies filter patterns as needed to guarantee that the entities in dbentity_list are captured by the specified filter.
setFilterValue	This action sets a filter’s value.
addMappingFilter	This action adds a new mapping filter for the mesher mode.
deleteMappingFilter	This action deletes a mapping filter.
setMappingFilterName	This action renames a mapping filter.
getMappingFilterNames	This action returns a list of mapping filter names defined in the mesher mode.
getMappingFilterCount	This action returns the number of mapping filters of the defined in the mesher mode.
getMappingFilterDefinition	This action gets the definition of a mapping filter identified by index or name.
getMappingFilterDefinitions	This action gets a list of all mapping filter definitions.
getMappingFilterEntityCounts	This action matches the name of each mode entity against the mapping filter patterns in filter priority order and returns the match count for each filter.
setMappingFilterPriority	This action sets the priority of one or more existing mapping filters.
setMappingFilterPatterns	This action sets the patterns of an existing mapping filters.
setMappingFilterEntities	This action modifies mapping filter patterns as needed to guarantee that the entities in dbentity_list are captured by the specified filter.
setMappingFilterValue	This action sets a mapping filter’s value.
setMappingFilterEqualSpacing	This action sets a mapping filter to use equal spacing.
getMappingFilterEqualSpacing	This action returns whether a mapping filter uses equal spacing.
setMappingFilterForceAdjacentGrid	This action sets a mapping filter to force adjacent grid spacing on neighboring surface grids.
getMappingFilterForceAdjacentGrid	This action returns whether a mapping filter forces adjacent grid spacing on neighboring surface grids.
setMappingFilterMaximumAspectRatio	This action sets a mapping filter’s maximum aspect ratio.
getMappingFilterMaximumAspectRatio	This action returns the maximum aspect ratio allowed for a mapped domain.
getMappingResult	This action gets whether or not a created unstructured domain was mapped to a structured domain.
addBoundaryFilter	This action adds a new boundary filter to control how stretching is applied to the matching boundaries.
deleteBoundaryFilter	This function deletes an existing boundary filter.
getBoundaryFilterNames	This function returns a list of the names of the current boundary filters.
setBoundaryFilterName	This action changes the name of an existing boundary filter.
setBoundaryFilterDefinition	This action specifies the patterns used to select which quilt boundaries will have the boundary conditions applied.
getBoundaryFilterDefinition	This function returns the current definition for a boundary filter.
addBoundaryFilterDefinition	This method adds a new entry to the end of a current boundary filter definition.
getBoundaryFilterGrowthType	This action returns the growth type associated with the boundary filter.
setBoundaryFilterGrowthType	This action sets the growth type associated with the boundary filter.
getBoundaryFilterGrowthRate	This action gets the growth rate associated with the boundary filter.
setBoundaryFilterGrowthRate	This action sets the growth rate associated with the boundary filter.
getBoundaryFilterGrowthAngle	This action gets the growth angle associated with an Angle boundary filter.
setBoundaryFilterGrowthAngle	This action sets the growth angle associated with a boundary filter of type Angle.
getBoundaryFilterGrowthMaximumAspectRatio	This action gets the maximum aspect ratio associated with a boundary filter.
setBoundaryFilterGrowthMaximumAspectRatio	This action sets the growth maximum aspect ratio associated with a boundary filter.
getBoundaryFilterGrowthWallSpacing	This action gets the initial growth boundary spacing for a Wall boundary filter.
setBoundaryFilterGrowthWallSpacing	This action sets the growth initial spacing for a Wall boundary filter.
getBoundaryFilterGrowthRateDelay	This action gets the growth rate delay associated with the boundary filter.
setBoundaryFilterGrowthRateDelay	This action sets the growth rate delay associated with the boundary filter.
getBoundaryFilterMinimumSubdivisionLength	This action gets the lower limit for cell spacing along the boundaries matched by the filter.
setBoundaryFilterMinimumSubdivisionLength	This action sets the target lower limit for cell spacing along a boundary.
getBoundaryFilterMinimumRadiusOfCurvature	This action gets the lower limit for cell spacing along the boundaries matched by the filter.
setBoundaryFilterMinimumRadiusOfCurvature	This action sets the target lower limit for evaluating the radius of curvature along a boundary.
getBoundaryFilterSpacingFactor	This function gets the factor used to scale the spacing of the boundaries associated with the filter.
setBoundaryFilterSpacingFactor	This function sets the factor used to scale the spacing of the boundaries associated with the filter.
getBoundaryFilterGroups	This action returns a list of quilt boundaries associated with a boundary filter.
setBoundaryFilterPriority	This sets the priority of one or more existing boundary filters.

addFilter

$mesher addFilter ?-type filter_type? ?-priority < index | name >? ?-name name? value ?pattern_list?

This action adds a new, mesher mode filter to a filter queue.

Parameters

-type filter_type	This optional parameter specifies the string type of the value parameter. One of < MaximumEdgeSpacing >. Each filter_type has an associated filter queue.
-priority < index \| name >	This optional parameter specifies the priority of the new filter. The new filter will be inserted into the filter_type queue before the (existing) filter identified by its integer index or string name. If not specified, the new filter is appended to the filter queue (lowest priority).
-name name	This optional parameter is the string filter name. If not provided, a unique “filter-N” name will be assigned.
value	This required parameter is the filter’s value. See Ranges section below.
pattern_list	This optional parameter defines the list of string patterns that will be used to match against database entity names. The default is an empty list (matches nothing).

Returns

This action returns the name of the added filter.

Notes

When applying filters, each entity’s name is matched against each filter in a queue. Within a queue, each filter is tried in priority order. The first match within a queue stops searching, applies the filter to the matched entity, and then continues matching with the next filter queue.

MaximumEdgeSpacing filters are matched against quilts. For each match, a quilt source is created with the specified value.

ThinSurfaceSubdivision filters are matched against quilts. For each match, the domain built from the quilt will have special thin surface handling controlled by the value.

Ranges

MaximumEdgeSpacing

value is a float in the range [0, infinity).

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addFilter -name F3 0.3 {quilt-1* quilt-2 quilt-4 !quilt-11}
$mesher addFilter -priority 1  -name F1 0.1 {quilt-4 quilt-5}
$mesher addFilter -priority F3 -name F2 0.2 quilt-3

puts "\$mesher getFilterDefinitions -dict"
dict for {priority filterDefn} [$mesher getFilterDefinitions -dict] {
    puts "$priority [list $filterDefn]"
    dict for {key val} $filterDefn {
        puts [format "  %-10.10s = %-s" $key $val]
    }
    puts ""
}

# Global filter always exists and always lowest priority
puts "\$mesher addFilter -name Global 0.2 bad*"
catch {$mesher addFilter -name Global 0.2 bad*} err
puts $err

Output

$mesher getFilterDefinitions -dict
1 {Type MaximumEdgeSpacing Priority 1 Name F1 Value 0.1 Patterns {quilt-4 quilt-5}}
  Type       = MaximumEdgeSpacing
  Priority   = 1
  Name       = F1
  Value      = 0.1
  Patterns   = quilt-4 quilt-5

2 {Type MaximumEdgeSpacing Priority 2 Name F2 Value 0.2 Patterns quilt-3}
  Type       = MaximumEdgeSpacing
  Priority   = 2
  Name       = F2
  Value      = 0.2
  Patterns   = quilt-3

3 {Type MaximumEdgeSpacing Priority 3 Name F3 Value 0.3 Patterns {quilt-1* quilt-2 quilt-4 !quilt-11}}
  Type       = MaximumEdgeSpacing
  Priority   = 3
  Name       = F3
  Value      = 0.3
  Patterns   = quilt-1* quilt-2 quilt-4 !quilt-11

4 {Type MaximumEdgeSpacing Priority 4 Name Global Value 0.0 Patterns *}
  Type       = MaximumEdgeSpacing
  Priority   = 4
  Name       = Global
  Value      = 0.0
  Patterns   = *

$mesher addFilter -name Global 0.2 bad*
ERROR: Filter Global already exists.

getFilterDefinition

$mesher getFilterDefinition ?-type filter_type? ?-dict? < index | name >

This action gets the definition of a filter identified by index or name.

Parameters

-type filter_type	This optional parameter specifies the string filter type. One of < MaximumEdgeSpacing >.
-dict	This optional flag signifies that the return value should be formatted as a dictionary instead of a plain old list.
index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.

Returns

This action returns the filter definition as a list.

A returned list contains { type priority name value patterns }.

A return dictionary is suitable for use with the dict command and is of the form: { Type type Priority priority Name name Value value Patterns patterns }

Where,

type is the string type of the filter.
priority is the integer priority of the filter.
name is the string name of the filter
value is the value of the filter (see addFilter for details)
patterns is a string list of glob patterns matched against entity names.

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addFilter F1 0.1 {quilt-1* wing-1*}
$mesher addFilter F2 0.2 {quilt-2* wing-2*}

foreach name [$mesher getFilterNames] {
    puts ""
    puts "\$mesher getFilterDefinition [list $name]:"
    puts "    list[list [$mesher getFilterDefinition $name]]"
    puts "\$mesher getFilterDefinition -dict [list $name]:"
    dict for {key val} [$mesher getFilterDefinition -dict $name] {
        puts [format "    %-10.10s: %-s" $key $val]
    }
}
puts ""
for {set ii 1} {$ii <= [$mesher getFilterCount]} {incr ii} {
    puts ""
    puts "\$mesher getFilterDefinition $ii:"
    puts "    list[list [$mesher getFilterDefinition $ii]]"
    puts "\$mesher getFilterDefinition -dict $ii:"
    dict for {key val} [$mesher getFilterDefinition -dict $ii] {
        puts [format "    %-10.10s: %-s" $key $val]
    }
}

Output

$mesher getFilterDefinition F1:
    list{MaximumEdgeSpacing 1 F1 0.1 {quilt-1* wing-1*}}
$mesher getFilterDefinition -dict F1:
    Type      : MaximumEdgeSpacing
    Priority  : 1
    Name      : F1
    Value     : 0.1
    Patterns  : quilt-1* wing-1*

$mesher getFilterDefinition F2:
    list{MaximumEdgeSpacing 2 F2 0.2 {quilt-2* wing-2*}}
$mesher getFilterDefinition -dict F2:
    Type      : MaximumEdgeSpacing
    Priority  : 2
    Name      : F2
    Value     : 0.2
    Patterns  : quilt-2* wing-2*

$mesher getFilterDefinition Global:
    list{MaximumEdgeSpacing 3 Global 0.0 *}
$mesher getFilterDefinition -dict Global:
    Type      : MaximumEdgeSpacing
    Priority  : 3
    Name      : Global
    Value     : 0.0
    Patterns  : *


$mesher getFilterDefinition 1:
    list{MaximumEdgeSpacing 1 F1 0.1 {quilt-1* wing-1*}}
$mesher getFilterDefinition -dict 1:
    Type      : MaximumEdgeSpacing
    Priority  : 1
    Name      : F1
    Value     : 0.1
    Patterns  : quilt-1* wing-1*

$mesher getFilterDefinition 2:
    list{MaximumEdgeSpacing 2 F2 0.2 {quilt-2* wing-2*}}
$mesher getFilterDefinition -dict 2:
    Type      : MaximumEdgeSpacing
    Priority  : 2
    Name      : F2
    Value     : 0.2
    Patterns  : quilt-2* wing-2*

$mesher getFilterDefinition 3:
    list{MaximumEdgeSpacing 3 Global 0.0 *}
$mesher getFilterDefinition -dict 3:
    Type      : MaximumEdgeSpacing
    Priority  : 3
    Name      : Global
    Value     : 0.0
    Patterns  : *

getFilterEntityCounts

$mesher getFilterEntityCounts ?-type filter_type? ?-includeEntities? ?-dict?

This action matches the name of each mode entity against the filter patterns in filter priority order and returns the match count for each filter.

Parameters

-type filter_type	This optional parameter specifies the string filter type. One of < MaximumEdgeSpacing >.
-includeEntities	This optional flag signifies that the matching entities should also be included in the return value.
-dict	This optional flag signifies that the return value should be formatted as a dictionary instead of a list.

Returns

This action returns the entity match count for each filter as a list or dictionary.

Note

Once an entity matches a filter, it is removed from consideration for lower priority filters. That is, each entity is only counted once.

A return list is of the form: {filtername entcnt ?entitylist? ... filtername entcnt ?entitylist?}

A return dictionary is suitable for use with the dict command and is of the form: {filtername {Count entcnt ?Entities entitylist?} ... filtername {Count entcnt ?Entities entitylist?}}

Filters that do not match any mode entity names are not included in the return.

Mode entities that do not match any filter are included in the return in the Global filter.

Example

Code

# $mesher is a DatabaseMesher mode
# $dbEnts is a list of database entities

proc toNames { ents } {
    set ret [list]
    foreach ent $ents {
        lappend ret [$ent getName]
    }
    return $ret
}

puts "All Database Entities:"
puts "  [toNames $dbEnts]"
puts ""

$mesher addFilter F1 0.1 {quilt-4 quilt-5 {WING X*}}
$mesher addFilter F2 0.2 quilt-3
$mesher addFilter F3 0.3 {quilt-1* quilt-2 quilt-4 !quilt-11}

# format template
set fmt "| %-6.6s | %3.3s | %-30.30s | %-35.35s |"
set hr [string repeat - 50]

puts "\$mesher getFilterEntityCounts -includeEntities"
puts [format $fmt Filter Cnt "Matched Entities" Patterns]
puts [format $fmt $hr $hr $hr $hr]
foreach {name entCnt ents} [$mesher getFilterEntityCounts -includeEntities] {
    set patterns [dict get [$mesher getFilterDefinition -dict $name] Patterns]
    puts [format $fmt $name $entCnt [list [toNames $ents]] $patterns]
}

puts ""
puts "\$mesher getFilterEntityCounts -dict -includeEntities"
puts [format $fmt Filter Cnt "Matched Entities" Patterns]
puts [format $fmt $hr $hr $hr $hr]
dict for {name keyVals} [$mesher getFilterEntityCounts -dict -includeEntities] {
    set entCnt [dict get $keyVals Count]
    set ents [dict get $keyVals Entities]
    set patterns [dict get [$mesher getFilterDefinition -dict $name] Patterns]
    puts [format $fmt $name $entCnt [list [toNames $ents]] $patterns]
}

Output

All Database Entities:
  body_0 quilt-1 quilt-2 quilt-3 quilt-4 quilt-5 quilt-12 {WING XL} quilt-11

$mesher getFilterEntityCounts -includeEntities
| Filter | Cnt | Matched Entities               | Patterns                            |
| ------ | --- | ------------------------------ | ----------------------------------- |
| F1     |   3 | {quilt-4 quilt-5 {WING XL}}    | quilt-4 quilt-5 {WING X*}           |
| F2     |   1 | quilt-3                        | quilt-3                             |
| F3     |   3 | {quilt-1 quilt-2 quilt-12}     | quilt-1* quilt-2 quilt-4 !quilt-11  |
| Global |   1 | quilt-11                       | *                                   |

$mesher getFilterEntityCounts -dict -includeEntities
| Filter | Cnt | Matched Entities               | Patterns                            |
| ------ | --- | ------------------------------ | ----------------------------------- |
| F1     |   3 | {quilt-4 quilt-5 {WING XL}}    | quilt-4 quilt-5 {WING X*}           |
| F2     |   1 | quilt-3                        | quilt-3                             |
| F3     |   3 | {quilt-1 quilt-2 quilt-12}     | quilt-1* quilt-2 quilt-4 !quilt-11  |
| Global |   1 | quilt-11                       | *                                   |

setFilterPriority

$mesher setFilterPriority ?-type filter_type? name_list

This action sets the priority of one or more existing filters.

Parameters

-type filter_type	This optional parameter specifies the string filter type. One of < MaximumEdgeSpacing >.
name_list	This parameter is a list of string filter names. Any filters not in name_list will be prioritized after the entities in name_list.

Returns

This action returns nothing.

Note

The relative ordering of the re-prioritized filters will be maintained.

Example

Code

# $mesher is a DatabaseMesher mode

proc doSetPriority { mesher names } {
    puts "\$mesher setFilterPriority [list $names]:"
    if { [catch {$mesher setFilterPriority $names} err] } {
        puts "  [string trim $err]"
    } else {
        puts "  [$mesher getFilterNames]"
    }
}

$mesher addFilter F1 0.1 {quilt-1*}
$mesher addFilter F2 0.2 {quilt-2*}
$mesher addFilter F3 0.3 {quilt-3*}
$mesher addFilter F4 0.4 {quilt-4*}
$mesher addFilter F5 0.5 {quilt-5*}
$mesher addFilter F6 0.6 {quilt-6*}

puts "Starting filter priority:"
puts "  [$mesher getFilterNames]"
doSetPriority $mesher {F2 F6 F4}
doSetPriority $mesher F6
doSetPriority $mesher {F6 F5 F4 F3 F2 F1}
puts "\nThese will fail:"
doSetPriority $mesher {F4 F2 F4 F2}
doSetPriority $mesher {XX YY}
doSetPriority $mesher {F4 F2 F4 XX}
doSetPriority $mesher {F2 Global F6 F4}

Output

Starting filter priority:
  F1 F2 F3 F4 F5 F6 Global
$mesher setFilterPriority {F2 F6 F4}:
  F2 F6 F4 F1 F3 F5 Global
$mesher setFilterPriority F6:
  F6 F2 F4 F1 F3 F5 Global
$mesher setFilterPriority {F6 F5 F4 F3 F2 F1}:
  F6 F5 F4 F3 F2 F1 Global

These will fail:
$mesher setFilterPriority {F4 F2 F4 F2}:
  ERROR: Found duplicate filter names {F4 F2}.
$mesher setFilterPriority {XX YY}:
  ERROR: Filters {XX YY} do not exist.
$mesher setFilterPriority {F4 F2 F4 XX}:
  ERROR: Filter XX does not exist. Found duplicate filter name F4.
$mesher setFilterPriority {F2 Global F6 F4}:
  ERROR: Cannot change the Global filter priority.

setFilterEntities

$mesher setFilterEntities ?-type filter_type? ?-op op_type? < index | name > dbentity_list

This action modifies filter patterns as needed to guarantee that the entities in dbentity_list are captured by the specified filter.

Parameters

-type filter_type	This optional parameter specifies the string filter type. One of < MaximumEdgeSpacing >.
-op op_type	This optional parameter specifies the string operation type. One of < Set \| Remove >.
index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.
dbentity_list	This parameter is a list of pw::DatabaseEntity objects, or a single pw::DatabaseEntity object.

Returns

This action returns nothing.

Note

Other filters may need to be adjusted to properly fulfill the requested configure operation. For instance, to add or set entities on a filter, those same entities will be removed from other filters as needed so that they no longer capture those entities.

Example

Code

# $mesher is a DatabaseMesher mode
# $dbEnts is a list of database entities

proc toNames { ents } {
    set ret [list]
    foreach ent $ents {
        lappend ret [$ent getName]
    }
    return $ret
}

proc dumpPatterns { mesher } {
    set filterCnts [$mesher getFilterEntityCounts -dict -includeEntities]
    set fmt "| %-6.6s | %-37.37s | %-55.55s |"
    set hr [string repeat - 80]
    puts [format $fmt Filter Patterns "Matched Entities"]
    puts [format $fmt $hr $hr $hr]
    foreach name [$mesher getFilterNames] {
        set defn [$mesher getFilterDefinition -dict $name]
        if { [catch {dict get $filterCnts $name Entities} ents] } {
            set ents [list]
        }
        puts [format $fmt $name [dict get $defn Patterns] [toNames $ents]]
    }
}

set quilts [list]
set names {quilt-11 quilt-2 quilt-1}
foreach name $names {
    lappend quilts [pw::DatabaseEntity getByName $name]
}

$mesher addFilter F1 0.1 {quilt-1*}
$mesher addFilter F2 0.2 {quilt-2*}
$mesher addFilter F3 0.3 {quilt-1* quilt-3*}

puts "All Database Entities:"
puts "  [toNames $dbEnts]"
puts ""
dumpPatterns $mesher
puts ""
puts "\$mesher setFilterEntities -op Set F2 [list $names]"
$mesher setFilterEntities -op Set F2 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setFilterEntities -op Set F3 [list $names]"
$mesher setFilterEntities -op Set F3 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setFilterEntities F1 [list $names]"
$mesher setFilterEntities F1 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setFilterEntities -op Remove F1 [list $names]"
$mesher setFilterEntities -op Remove F1 $quilts
dumpPatterns $mesher
puts ""
# Setting entities to the Global filter removes them from all other filters
puts "\$mesher setFilterEntities Global [list $names]"
$mesher setFilterEntities Global $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setFilterEntities -op Remove Global [list $names]"
catch {$mesher setFilterEntities -op Remove Global $quilts} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"

Output

All Database Entities:
  body_0 quilt-1 quilt-2 quilt-3 quilt-4 quilt-5 quilt-12 {WING XL} quilt-11

| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1*                              | quilt-1 quilt-12 quilt-11                               |
| F2     | quilt-2*                              | quilt-2                                                 |
| F3     | quilt-1* quilt-3*                     | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setFilterEntities -op Set F2 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* quilt-11 quilt-1             | quilt-1 quilt-2 quilt-11                                |
| F3     | quilt-1* quilt-3*                     | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setFilterEntities -op Set F3 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-1 quilt-2 quilt-3 quilt-11                        |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setFilterEntities F1 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* quilt-2                      | quilt-1 quilt-2 quilt-12 quilt-11                       |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setFilterEntities -op Remove F1 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-1 quilt-2 quilt-3 quilt-11                        |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setFilterEntities Global {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* !quilt-11 !quilt-1  | quilt-3                                                 |
| Global | *                                     | quilt-1 quilt-2 quilt-4 quilt-5 {WING XL} quilt-11      |

$mesher setFilterEntities -op Remove Global {quilt-11 quilt-2 quilt-1}
  ERROR: Cannot remove entities from the Global filter.

setFilterValue

$mesher setFilterValue ?-type filter_type? < index | name > value

This action sets a filter’s value.

Parameters

-type filter_type	This optional parameter specifies the string filter type. One of < MaximumEdgeSpacing >.
index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.
value	The filter’s new value. The value’s type and range depend on the filter_type. See Ranges section below.

Returns

This action returns nothing.

Ranges

MaximumEdgeSpacing	value is a float in the range [0, infinity).
ThinSurfaceInterpolation	value is string with valid values < None \| Automatic \| ThinSurfaceInterpolation > or an integer with the range [2, infinity).

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addFilter F1 0.1 {quilt-1*}

puts "value: [dict get [$mesher getFilterDefinition -dict F1] Value]"
$mesher setFilterValue F1 0.9
puts "\n\$mesher setFilterValue F1 0.9"
puts "value: [dict get [$mesher getFilterDefinition -dict F1] Value]"

puts "\n\$mesher setFilterValue F1 -1.0"
catch {$mesher setFilterValue F1 -1.0} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"
puts "value: [dict get [$mesher getFilterDefinition -dict F1] Value]"

puts "\n\$mesher setFilterValue Q1 1.0"
catch {$mesher setFilterValue Q1 1.0} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"

Output

value: 0.1

$mesher setFilterValue F1 0.9
value: 0.9

$mesher setFilterValue F1 -1.0
  ERROR: value outside the range [0,infinity)
  ERROR: usage (argument 3): ::pw::DatabaseMesher_1 setFilterValue ?-type filter_type? < index | name > value
value: 0.9

$mesher setFilterValue Q1 1.0
  ERROR: Filter 'Q1' does not exist.
  ERROR: usage (argument 2): ::pw::DatabaseMesher_1 setFilterValue ?-type filter_type? < index | name > value

addMappingFilter

$mesher addMappingFilter ?-priority < index | name >? ?-name name? value ?pattern_list ?equal_spacing ?force_adjacent ?max_aspect_ratio?

This action adds a new mapping filter for the mesher mode. A mapping filter controls whether unstructured domains on quilts are mapped to structured domains or initialized via the Thin Surface Interpolation algorithm.

Parameters

-priority < index \| name >	This optional flag specifies the priority of the new mapping filter. The new mapping filter will be inserted into the mapping filter queue before the (existing) mapping filter identified by its integer index or string name. If not specified, the new filter is appended to the filter queue (lowest priority).
-name name	This optional flag is the string mapping filter name. If not provided, a unique “filter-N” name will be assigned.
value	This required parameter is the mapping filter’s value. See Ranges section below.
pattern_list	This optional parameter defines the list of string patterns that will be used to match against database entity names. The default is an empty list (matches nothing).
equals_spacing	This optional boolean parameter controls whether or not equal spacing is applied along the short direction. The default value is false.
force_adjacent	If this optional boolean parameter is set to true, adjacent domains will have their neighboring boundaries set to use the adjacent grid boundary condition. The default value is false.
max_aspect_ratio	If set, this float parameter overrides the global maximum aspect ratio setting for any domain that maps to this filter. The default value is 0.0, which forces the global value to be used.

Returns

This action returns the name of the added mapping filter.

Notes

When applying mapping filters, each entity’s name is matched against each mapping filter in a queue. Within a queue, each mapping filter is tried in priority order. The first match within a queue stops searching, applies the mapping filter to the matched entity, and then continues matching with the next mapping filter.

Mapping filters are matched against quilts. For each match, the domain built from the quilt will have special thin surface handling controlled by the value. A value of “None” causes the corresponding domains to be initialized normally without any special thin surface handling. A value of “Automatic” is the default behavior and analyzes the domains to see if it is appropriate to map the unstructured domain to a corresponding structured domain, setting an appropriate number of subdivisions for the shorter sides of the domain. The “ThinSurfaceInterpolation” setting will result in the domains getting initialized with the Thin Surface Interpolation algorithm. The matching domains will not be mapped, but the resulting algorithm produces a similar result while allowing the dimensions to differ on opposing sides. The “Force” value skips a large portion of the analysis performed with the “Automatic” mode and will map the filtered domains to structured domains where feasible regardless of any analytics with regard to aspect ratio, etc. The number of subdivisions on the shorter sides will be automatically computed by the code. Finally, an integer value of 2 or greater is similar to the “Force” value except that the number of subdivisions on the short edges is set to the given value.

Note that if the quilt has more than one boundary loop (i.e., holes) or has less that 4 boundaries, the resulting domains will not be mapped, regardless of the mapping filter specifications.

Ranges

A valid value is string with valid values < None | Automatic | Force | ThinSurfaceInterpolation > or an integer with the range [2, infinity).

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addMappingFilter -name F3 3 {quilt-1* quilt-2 quilt-4 !quilt-11} 1 1 20.0
$mesher addMappingFilter -priority 1  -name F1 Automatic {quilt-4 quilt-5}
$mesher addMappingFilter -priority F3 -name F2 ThinSurfaceInterpolation quilt-3 0 1

puts "\$mesher getMappingFilterDefinitions -dict"
dict for {priority filterDefn} [$mesher getMappingFilterDefinitions -dict] {
    puts "$priority [list $filterDefn]"
    dict for {key val} $filterDefn {
        puts [format "  %-19.19s = %-s" $key $val]
    }
    puts ""
}

# Global filter always exists and always has the lowest priority
puts "\$mesher addMappingFilter -name Global 2 bad*"
catch {$mesher addMappingFilter -name Global 2 bad*} err
puts $err

Output

$mesher getMappingFilterDefinitions -dict
1 {Priority 1 Name F1 Value Automatic Patterns {quilt-4 quilt-5}}
  Priority           = 1
  Name               = F1
  Value              = Automatic
  Patterns           = quilt-4 quilt-5
  EqualSpacing       = 0
  ForceAdjacentGrid  = 0
  MaximumAspectRatio = 0.0

2 {Priority 2 Name F2 Value ThinSurfaceInterpolation Patterns quilt-3}
  Priority           = 2
  Name               = F2
  Value              = ThinSurfaceInterpolation
  Patterns           = quilt-3
  EqualSpacing       = 0
  ForceAdjacentGrid  = 1
  MaximumAspectRatio = 0.0

3 {Priority 3 Name F3 Value 3 Patterns {quilt-1* quilt-2 quilt-4 !quilt-11}}
  Priority           = 3
  Name               = F3
  Value              = 3
  Patterns           = quilt-1* quilt-2 quilt-4 !quilt-11
  EqualSpacing       = 1
  ForceAdjacentGrid  = 1
  MaximumAspectRatio = 20.0

4 {Priority 4 Name Global Value Automatic Patterns *}
  Priority           = 4
  Name               = Global
  Value              = Automatic
  Patterns           = *
  EqualSpacing       = 0
  ForceAdjacentGrid  = 0
  MaximumAspectRatio = 0.0

$mesher addMappingFilter -name Global 5 bad*
ERROR: Filter Global already exists.

getMappingFilterDefinition

$mesher getMappingFilterDefinition ?-type filter_type? ?-dict? < index | name >

This action gets the definition of a mapping filter identified by index or name.

Parameters

-dict	This optional flag signifies that the return value should be formatted as a dictionary instead of a plain old list.
index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.

Returns

This action returns the filter definition as a list.

A returned list contains { priority name value patterns }.

A return dictionary is suitable for use with the dict command and is of the form: { Priority priority Name name Value value Patterns patterns }

Where,

priority is the integer priority of the filter.
name is the string name of the filter
value is either a string equaling either “None”, “Automatic”, “Force”, “ThinSurfaceInterpolation”, or an integer value representing the number of subdivisions to use on a “Force” mapping (see addMappingFilter for details)
patterns is a string list of glob patterns matched against entity names.

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addMappingFilter F1 Automatic {quilt-1* wing-1*}
$mesher addMappingFilter F2 2 {quilt-2* wing-2*}

foreach name [$mesher getMappingFilterNames] {
    puts ""
    puts "\$mesher getMappingFilterDefinition [list $name]:"
    puts "    list[list [$mesher getMappingFilterDefinition $name]]"
    puts "\$mesher getMappingFilterDefinition -dict [list $name]:"
    dict for {key val} [$mesher getMappingFilterDefinition -dict $name] {
        puts [format "    %-10.10s: %-s" $key $val]
    }
}
puts ""
for {set ii 1} {$ii <= [$mesher getMappingFilterCount]} {incr ii} {
    puts ""
    puts "\$mesher getMappingFilterDefinition $ii:"
    puts "    list[list [$mesher getMappingFilterDefinition $ii]]"
    puts "\$mesher getMappingFilterDefinition -dict $ii:"
    dict for {key val} [$mesher getMappingFilterDefinition -dict $ii] {
        puts [format "    %-10.10s: %-s" $key $val]
    }
}

Output

$mesher getMappingFilterDefinition F1:
    list{1 F1 Automatic {quilt-1* wing-1*}}
$mesher getMappingFilterDefinition -dict F1:
    Priority  : 1
    Name      : F1
    Value     : Automatic
    Patterns  : quilt-1* wing-1*

$mesher getMappingFilterDefinition F2:
    list{2 F2 2 {quilt-2* wing-2*}}
$mesher getMappingFilterDefinition -dict F2:
    Priority  : 2
    Name      : F2
    Value     : 2
    Patterns  : quilt-2* wing-2*

$mesher getMappingFilterDefinition Global:
    list{3 Global 0.0 *}
$mesher getMappingFilterDefinition -dict Global:
    Priority  : 3
    Name      : Global
    Value     : Automatic
    Patterns  : *


$mesher getMappingFilterDefinition 1:
    list{1 F1 Automatic {quilt-1* wing-1*}}
$mesher getMappingFilterDefinition -dict 1:
    Priority  : 1
    Name      : F1
    Value     : Automatic
    Patterns  : quilt-1* wing-1*

$mesher getMappingFilterDefinition 2:
    list{2 F2 0.2 {quilt-2* wing-2*}}
$mesher getMappingFilterDefinition -dict 2:
    Priority  : 2
    Name      : F2
    Value     : 2
    Patterns  : quilt-2* wing-2*

$mesher getMappingFilterDefinition 3:
    list{3 Global 0.0 *}
$mesher getMappingFilterDefinition -dict 3:
    Priority  : 3
    Name      : Global
    Value     : Automatic
    Patterns  : *

getMappingFilterEntityCounts

$mesher getMappingFilterEntityCounts ?-type filter_type? ?-includeEntities? ?-dict?

This action matches the name of each mode entity against the mapping filter patterns in filter priority order and returns the match count for each filter.

Parameters

-includeEntities	This optional flag signifies that the matching entities should also be included in the return value.
-dict	This optional flag signifies that the return value should be formatted as a dictionary instead of a list.

Returns

This action returns the entity match count for each filter as a list or dictionary.

Note

Once an entity matches a mapping filter, it is removed from consideration for lower priority filters. That is, each entity is only counted once.

A return list is of the form: {filtername entcnt ?entitylist? ... filtername entcnt ?entitylist?}

A return dictionary is suitable for use with the dict command and is of the form: {filtername {Count entcnt ?Entities entitylist?} ... filtername {Count entcnt ?Entities entitylist?}}

Filters that do not match any mode entity names are not included in the return.

Mode entities that do not match any filter are included in the return in the Global filter.

Example

Code

# $mesher is a DatabaseMesher mode
# $dbEnts is a list of database entities

proc toNames { ents } {
    set ret [list]
    foreach ent $ents {
        lappend ret [$ent getName]
    }
    return $ret
}

puts "All Database Entities:"
puts "  [toNames $dbEnts]"
puts ""

$mesher addMappingFilter F1 ThinSurfaceInterpolation {quilt-4 quilt-5 {WING X*}}
$mesher addMappingFilter F2 2 quilt-3
$mesher addMappingFilter F3 3 {quilt-1* quilt-2 quilt-4 !quilt-11}

# format template
set fmt "| %-6.6s | %3.3s | %-30.30s | %-35.35s |"
set hr [string repeat - 50]

puts "\$mesher getMappingFilterEntityCounts -includeEntities"
puts [format $fmt Filter Cnt "Matched Entities" Patterns]
puts [format $fmt $hr $hr $hr $hr]
foreach {name entCnt ents} [$mesher getMappingFilterEntityCounts -includeEntities] {
    set patterns [dict get [$mesher getFilterDefinition -dict $name] Patterns]
    puts [format $fmt $name $entCnt [list [toNames $ents]] $patterns]
}

puts ""
puts "\$mesher getMappingFilterEntityCounts -dict -includeEntities"
puts [format $fmt Filter Cnt "Matched Entities" Patterns]
puts [format $fmt $hr $hr $hr $hr]
dict for {name keyVals} [$mesher getMappingFilterEntityCounts -dict -includeEntities] {
    set entCnt [dict get $keyVals Count]
    set ents [dict get $keyVals Entities]
    set patterns [dict get [$mesher getFilterDefinition -dict $name] Patterns]
    puts [format $fmt $name $entCnt [list [toNames $ents]] $patterns]
}

Output

All Database Entities:
  body_0 quilt-1 quilt-2 quilt-3 quilt-4 quilt-5 quilt-12 {WING XL} quilt-11

$mesher getMappingFilterEntityCounts -includeEntities
| Filter | Cnt | Matched Entities               | Patterns                            |
| ------ | --- | ------------------------------ | ----------------------------------- |
| F1     |   3 | {quilt-4 quilt-5 {WING XL}}    | quilt-4 quilt-5 {WING X*}           |
| F2     |   1 | quilt-3                        | quilt-3                             |
| F3     |   3 | {quilt-1 quilt-2 quilt-12}     | quilt-1* quilt-2 quilt-4 !quilt-11  |
| Global |   1 | quilt-11                       | *                                   |

$mesher getMappingFilterEntityCounts -dict -includeEntities
| Filter | Cnt | Matched Entities               | Patterns                            |
| ------ | --- | ------------------------------ | ----------------------------------- |
| F1     |   3 | {quilt-4 quilt-5 {WING XL}}    | quilt-4 quilt-5 {WING X*}           |
| F2     |   1 | quilt-3                        | quilt-3                             |
| F3     |   3 | {quilt-1 quilt-2 quilt-12}     | quilt-1* quilt-2 quilt-4 !quilt-11  |
| Global |   1 | quilt-11                       | *                                   |

setMappingFilterPriority

$mesher setMappingFilterPriority name_list

This action sets the priority of one or more existing mapping filters.

Parameters

name_list

This parameter is a list of string mapping filter names. Any filters not in name_list will be prioritized after the entities in name_list.

Returns

This action returns nothing.

Note

The relative ordering of the re-prioritized mapping filters will be maintained.

Example

Code

# $mesher is a DatabaseMesher mode

proc doSetPriority { mesher names } {
    puts "\$mesher setMappingFilterPriority [list $names]:"
    if { [catch {$mesher setMappingFilterPriority $names} err] } {
        puts "  [string trim $err]"
    } else {
        puts "  [$mesher getMappingFilterNames]"
    }
}

$mesher addMappingFilter F1 ThinSurfaceInterpolation {quilt-1*}
$mesher addMappingFilter F2 2 {quilt-2*}
$mesher addMappingFilter F3 3 {quilt-3*}
$mesher addMappingFilter F4 4 {quilt-4*}
$mesher addMappingFilter F5 5 {quilt-5*}
$mesher addMappingFilter F6 6 {quilt-6*}

puts "Starting filter priority:"
puts "  [$mesher getMappingFilterNames]"
doSetPriority $mesher {F2 F6 F4}
doSetPriority $mesher F6
doSetPriority $mesher {F6 F5 F4 F3 F2 F1}
puts "\nThese will fail:"
doSetPriority $mesher {F4 F2 F4 F2}
doSetPriority $mesher {XX YY}
doSetPriority $mesher {F4 F2 F4 XX}
doSetPriority $mesher {F2 Global F6 F4}

Output

Starting filter priority:
  F1 F2 F3 F4 F5 F6 Global
$mesher setMappingFilterPriority {F2 F6 F4}:
  F2 F6 F4 F1 F3 F5 Global
$mesher setMappingFilterPriority F6:
  F6 F2 F4 F1 F3 F5 Global
$mesher setMappingFilterPriority {F6 F5 F4 F3 F2 F1}:
  F6 F5 F4 F3 F2 F1 Global

These will fail:
$mesher setMappingFilterPriority {F4 F2 F4 F2}:
  ERROR: Found duplicate filter names {F4 F2}.
$mesher setMappingFilterPriority {XX YY}:
  ERROR: Filters {XX YY} do not exist.
$mesher setMappingFilterPriority {F4 F2 F4 XX}:
  ERROR: Filter XX does not exist. Found duplicate filter name F4.
$mesher setMappingFilterPriority {F2 Global F6 F4}:
  ERROR: Cannot change the Global filter priority.

setMappingFilterEntities

$mesher setMappingFilterEntities ?-op op_type? < index | name > dbentity_list

This action modifies mapping filter patterns as needed to guarantee that the entities in dbentity_list are captured by the specified filter.

Parameters

-op op_type	This optional parameter specifies the string operation type. One of < Set \| Remove >.
index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.
dbentity_list	This parameter is a list of pw::DatabaseEntity objects, or a single pw::DatabaseEntity object.

Returns

This action returns nothing.

Note

Other mapping filters may need to be adjusted to properly fulfill the requested configure operation. For instance, to add or set entities on a mapping filter, those same entities will be removed from other mapping filters as needed so that they no longer capture those entities.

Example

Code

# $mesher is a DatabaseMesher mode
# $dbEnts is a list of database entities

proc toNames { ents } {
    set ret [list]
    foreach ent $ents {
        lappend ret [$ent getName]
    }
    return $ret
}

proc dumpPatterns { mesher } {
    set filterCnts [$mesher getMappingFilterEntityCounts -dict -includeEntities]
    set fmt "| %-6.6s | %-37.37s | %-55.55s |"
    set hr [string repeat - 80]
    puts [format $fmt Filter Patterns "Matched Entities"]
    puts [format $fmt $hr $hr $hr]
    foreach name [$mesher getMappingFilterNames] {
        set defn [$mesher getMappingFilterDefinition -dict $name]
        if { [catch {dict get $filterCnts $name Entities} ents] } {
            set ents [list]
        }
        puts [format $fmt $name [dict get $defn Patterns] [toNames $ents]]
    }
}

set quilts [list]
set names {quilt-11 quilt-2 quilt-1}
foreach name $names {
    lappend quilts [pw::DatabaseEntity getByName $name]
}

$mesher addMappingFilter F1 ThisSurfaceInterpolation {quilt-1*}
$mesher addMappingFilter F2 2 {quilt-2*}
$mesher addMappingFilter F3 3 {quilt-1* quilt-3*}

puts "All Database Entities:"
puts "  [toNames $dbEnts]"
puts ""
dumpPatterns $mesher
puts ""
puts "\$mesher setMappingFilterEntities -op Set F2 [list $names]"
$mesher setMappingFilterEntities -op Set F2 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setMappingFilterEntities -op Set F3 [list $names]"
$mesher setMappingFilterEntities -op Set F3 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setMappingFilterEntities F1 [list $names]"
$mesher setMappingFilterEntities F1 $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setMappingFilterEntities -op Remove F1 [list $names]"
$mesher setMappingFilterEntities -op Remove F1 $quilts
dumpPatterns $mesher
puts ""
# Setting entities to the Global mapping filter removes them from
# all other filters
puts "\$mesher setMappingFilterEntities Global [list $names]"
$mesher setMappingFilterEntities Global $quilts
dumpPatterns $mesher
puts ""
puts "\$mesher setMappingFilterEntities -op Remove Global [list $names]"
catch {$mesher setMappingFilterEntities -op Remove Global $quilts} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"

Output

All Database Entities:
  body_0 quilt-1 quilt-2 quilt-3 quilt-4 quilt-5 quilt-12 {WING XL} quilt-11

| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1*                              | quilt-1 quilt-12 quilt-11                               |
| F2     | quilt-2*                              | quilt-2                                                 |
| F3     | quilt-1* quilt-3*                     | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setMappingFilterEntities -op Set F2 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* quilt-11 quilt-1             | quilt-1 quilt-2 quilt-11                                |
| F3     | quilt-1* quilt-3*                     | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setMappingFilterEntities -op Set F3 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-1 quilt-2 quilt-3 quilt-11                        |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setMappingFilterEntities F1 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* quilt-2                      | quilt-1 quilt-2 quilt-12 quilt-11                       |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-3                                                 |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setMappingFilterEntities -op Remove F1 {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* quilt-2             | quilt-1 quilt-2 quilt-3 quilt-11                        |
| Global | *                                     | quilt-4 quilt-5 {WING XL}                               |

$mesher setMappingFilterEntities Global {quilt-11 quilt-2 quilt-1}
| Filter | Patterns                              | Matched Entities                                        |
| ------ | ------------------------------------- | ------------------------------------------------------- |
| F1     | quilt-1* !quilt-11 !quilt-1           | quilt-12                                                |
| F2     | quilt-2* !quilt-2                     |                                                         |
| F3     | quilt-1* quilt-3* !quilt-11 !quilt-1  | quilt-3                                                 |
| Global | *                                     | quilt-1 quilt-2 quilt-4 quilt-5 {WING XL} quilt-11      |

$mesher setMappingFilterEntities -op Remove Global {quilt-11 quilt-2 quilt-1}
  ERROR: Cannot remove entities from the Global filter.

setMappingFilterValue

This action sets a mapping filter’s value.

Parameters

index	This parameter is the integer index of the filter in the range [1, number of filters].
name	This parameter is the string filter name.
value	The filter’s new value. The value is a string with valid values < None \| Automatic \| Force \| ThinSurfaceInterpolation > or an integer with the range [2, infinity) representing the number of subdivisions along the short side of the mapped domain. The ‘None’ option will prevent a mapped domain from possibly being generated on the corresponding quilts. The ‘Automatic’ option is the default setting which lets the algorithm decide whether or not to generate a mapped domain. The ‘Force’ option indicates that a mapped domain should be generated on the corresponding quilts, but leaves it up to the algorithm to determine the number of subdivisions on the smaller sides of the domains. Note that this does not guarantee that mapped domains will be created -- there are still topological requirements that must be met. The ‘ThinSurfaceInterpolation’ option specifies that any domains created on the corresponding quilts should be initialized with the ‘ThinSurfaceInterpolation’ algorithm. Finally, an integer value is similar to the ‘Force’ option, but the integer value is used as the number of subdivisions to be imposed on the smaller sides of the domains.

Returns

This action returns nothing.

Example

Code

# $mesher is a DatabaseMesher mode
$mesher addMappingFilter F1 ThinSurfaceInterpolation {quilt-1*}

puts "value: [dict get [$mesher getMappingFilterDefinition -dict F1] Value]"
$mesher setMappingFilterValue F1 9
puts "\n\$mesher setMappingFilterValue F1 9"
puts "value: [dict get [$mesher getMappingFilterDefinition -dict F1] Value]"

puts "\n\$mesher setMappingFilterValue F1 -1.0"
catch {$mesher setMappingFilterValue F1 -1.0} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"
puts "value: [dict get [$mesher getMappingFilterDefinition -dict F1] Value]"

puts "\n\$mesher setMappingFilterValue Q1 1.0"
catch {$mesher setMappingFilterValue Q1 1.0} err
puts "  [join [split [string trim $err] "\n"] "\n  "]"

Output

value: 0.1

$mesher setMappingFilterValue F1 9
value: 0.9

$mesher setMappingFilterValue F1 -1
  ERROR: value outside the range [2,infinity)
  ERROR: usage (argument 3): ::pw::DatabaseMesher_1 setMappingFilterValue ?-type filter_type? < index | name > value
value: 0.9

$mesher setMappingFilterValue Q1 10
  ERROR: Filter 'Q1' does not exist.
  ERROR: usage (argument 2): ::pw::DatabaseMesher_1 setMappingFilterValue ?-type filter_type? < index | name > value

setBoundaryFilterDefinition

$mesher setBoundaryFilterDefinition filter_name pattern_list

This action specifies the patterns used to select which quilt boundaries will have the boundary conditions applied.

Parameters

filter_name	This parameter is the string boundary filter name.
pattern_list	This parameter is a list of filter patterns. A filter pattern entry must consist of a “Pattern A” element. It may optionally include a “Pattern B” element and/or a boundary classification element. See the Notes section for a description of each element.

Returns

This action returns nothing.

Notes

Filter Entry: A boundary filter entry consists of the following parts: pattern A, pattern B, and a list of boundary classifications.

Pattern A: This string can either be the name of a quilt or a pattern that can match multiple quilts. Wildcard patterns are specified with ‘*’, ‘?’, and ‘[‘ - ‘]’ pairs. A ‘*’ character matches any number (including zero) of characters. A ‘?’ character matches any single character. Brackets indicate a range of characters to match or exclude and has the following 4 available forms: “[abc]” matches one character given in the bracket, “[a-c]” matches one character from the range (inclusive) given in the bracket, “[!abc]” matches one character that is not in the bracket, and “[!a-c]” matches one character that is not in the range specified by the bracket. A backslash “\” can be used to escape any special meaning by a wildcard character. For example, “\?” will match a question mark while “?” will match any single character.

Pattern B: This string follows the same syntax as ‘Pattern A’. If the B pattern is empty, then this filter entry will be applied to lamina boundaries on the quilts that match pattern A. If the B pattern is non-empty, then the filter entry will only be applied to manifold boundaries shared between quilts that match pattern A and quilts that match pattern B and are not excluded by the specified boundary classifications. If omitted, an empty string is assumed.

Boundary Classifications: This list of 5 possible string values restricts the filter entry to boundaries that match the quilt patterns specified with Pattern A and Pattern B based on their classifications. The five classification options are: “All”, “None”, “Curvature”, “Convex”, and “Concave”. The “All” option indicates that all boundaries regardless of classification should be allowed. Note that “None” means boundaries that are not classified as either “Curvature”, “Convex”, or “Concave”. If the boundary classification list is not specified, “All” is assumed.

Example

Code

# Each entry has the following meaning:
#     Entry 1: any boundaries between any quilt that matches "upper-*" and
#         any quilt that matches "lower-*" regardless of classification
#         will be included.
#     Entry 2: any convex boundaries shared between any quilt that matches
#         "left-*" and any quilt that matches "right-*" will be included.
#     Entry 3: any boundaries not classified as convex or concave shared
#         between any quilt that matches "forward-*" and any quilt that
#         matches "aft-*" will be included.
#     Entry 4: any lamina boundaries on a quilt that matches "inner-*"
#         will be included, regardless of classification.
#     Entry 5: any lamina boundaries not classified as curvature, convex,
#         or concave on any quilt that matches "outer-*-aft" will be
#         included.
#     Entry 6: any lamina boundaries not classified as curvature, convex,
#         or concave on any quilt that matches "fuselage-*" will be
#         included.
#     Entry 7: any manifold boundaries not classified as curvature,
#         convex, or concave shared between a quilt that matches
#         "fuselage-*" and any other quilt will be included.
#     Entry 8: any boundaries regardless of classification shared between
#         any quilt that matches "canard-upper-*" and any quilt that
#         matches "canard-lower-*" will be included.
#     Entry 9: any curvature boundaries between the quilt named
#         "canard-upper-inner" and "canard-lower-inner" will be excluded.
#
# $mesher is a DatabaseMesher mode
set filter_name [$mesher addBoundaryFilter]
$mesher setBoundaryFilterDefinition $filter_name [list \
  {upper-* lower-*} \
  {left-* right-* Convex} \
  {forward-* aft-* {None Curvature}} \
  {inner-*} \
  {outer-*-aft None} \
  {fuselage-* None} \
  {fuselage-* * None} \
  {canard-upper-* canard-lower-*} \
  {!canard-upper-inner canard-lower-inner Curvature} \
  ]
puts "$filter_name elements:"
foreach entry [$mesher getBoundaryFilterDefinition $filter_name] {
  puts "  $entry"
}

Output

bf-1 elements:
 upper-* lower-* All
 left-* right-* Convex
 forward-* aft-* {None Curvature}
 inner-* {} All
 outer-*-aft {} None
 fuselage-* {} None
 fuselage-* * None
 canard-upper-* canard-lower-* All
 !canard-upper-inner canard-lower-inner Curvature

addBoundaryFilterDefinition

$mesher addBoundaryFilterDefinition filter_name pattern_list

This method adds a new entry to the end of a current boundary filter definition.

Parameters

filter_name	This parameter is the string boundary filter name.
pattern_list	This parameter is a list of filter patterns. See setBoundaryFilterDefinition for an explanation of filter patterns.

Note

While similar to setBoundaryFilterDefinition, this extends the existing filter and may remove earlier entries. This only occurs with explicit namings (no special pattern matching characters in the patterns) and only among entries after an entry that does use special pattern matching characters. For example, if a definition ends with the entry “{quilt-1 quilt-2 Curvature}” (additive entry) and this function adds “{!quilt-1 quilt-2 Curvature}” (subtractive entry), then the second entry nullifies the first entry, removing it from the list instead of adding to the list. Conversely, if a list ends with a subtractive entry and a matching additive entry is added, the subtractive entry will be removed from the list in addition to the additive entry being appended.

Returns

This action returns nothing.

Example

Code

# $mesher is a DatabaseMesher mode
# Set the initial definition
set filter_name [$mesher addBoundaryFilter]
$mesher setBoundaryFilterDefinition $filter_name [list \
  {upper-* lower-*} \
  {left-tail right-tail Convex} \
  {canard-upper-* canard-lower-*} \
  {!canard-upper-inner canard-lower-inner Curvature} \
  ]
puts "$filter_name elements:"
foreach entry [$mesher getBoundaryFilterDefinition $filter_name] {
  puts "  $entry"
}
puts "--"
# Cancel the subtractive entry
puts "\$mesher addBoundaryFilterDefinition \$filter_name \[list {canard-upper-inner canard-lower-inner Curvature}\]"
$mesher addBoundaryFilterDefinition $filter_name [list {canard-upper-inner canard-lower-inner Curvature}]
puts "$filter_name elements:"
foreach entry [$mesher getBoundaryFilterDefinition $filter_name] {
  puts "  $entry"
}
puts "--"
# Cancel the additive entry just added
puts "\$mesher addBoundaryFilterDefinition \$filter_name \[list {!canard-upper-inner canard-lower-inner Curvature}\]"
$mesher addBoundaryFilterDefinition $filter_name [list {!canard-upper-inner canard-lower-inner Curvature}]
puts "$filter_name elements:"
foreach entry [$mesher getBoundaryFilterDefinition $filter_name] {
  puts "  $entry"
}
puts "--"
# Add the convex boundaries between left-tail and right-tail to
# the list. Note the earlier matching subtractive entry wasn't
# removed because an entry with wildcard patterns exists after it.
puts "\$mesher addBoundaryFilterDefinition \$filter_name \[list {!left-tail right-tail Convex}\]"
$mesher addBoundaryFilterDefinition $filter_name [list {left-tail right-tail Convex}]
puts "$filter_name elements:"
foreach entry [$mesher getBoundaryFilterDefinition $filter_name] {
  puts "  $entry"
}

Output

bf-1 elements:
  upper-* lower-* All
  left-tail right-tail Convex
  canard-upper-* canard-lower-* All
  !canard-upper-inner canard-lower-inner Curvature
--
$mesher addBoundaryFilterDefinition $filter_name [list {canard-upper-inner canard-lower-inner Curvature}]
bf-1 elements:
  upper-* lower-* All
  left-tail right-tail Convex
  canard-upper-* canard-lower-* All
  canard-upper-inner canard-lower-inner Curvature
--
$mesher addBoundaryFilterDefinition $filter_name [list {!canard-upper-inner canard-lower-inner Curvature}]
bf-1 elements:
  upper-* lower-* All
  left-tail right-tail Convex
  canard-upper-* canard-lower-* All
--
$mesher addBoundaryFilterDefinition $filter_name [list {!left-tail right-tail Convex}]
bf-1 elements:
  upper-* lower-* All
  left-tail right-tail Convex
  canard-upper-* canard-lower-* All
  left-tail right-tail Convex

pw:: DatabaseMesher

Derives From

Notes

Instance Attributes

MergeTolerance

Type

Default

MinimumSpacingMode

Type

Default

Information

MinimumBoundarySubdivisions

Type

Default

Information

MinimumEdgeSpacing

Type

Default

Information

MinimumSubdivisionLength

Type

Default

Information

MinimumRadiusOfCurvature

Type

Default

Information

MaximumSpacingMode

Type

Default

Information

MaximumExtentsSubdivisions

Type

Default

Information

MaximumEdgeSpacing

Type

Default

Information

CurvatureResolutionAngle

Type

Default

MaximumAspectRatio

Type

Default

BoundaryGrowthRate

Type

Default

DomainAlgorithm

Type

Default

RefinementFactor

Type

Default

MappedSurfaceSubdivisionRatio

Type

Default

BoundaryProximityInfluence

Type

Default

Note

BoundaryGapSubdivisions

Type

Default

Information

StretchingBuffer

Type

Default

Information

BoundaryGroupAngle

Type

Default

BoundaryCurvatureRatio

Type

Default

BoundaryHardAngle

Type

Default

DomainAreaRatioThreshold

Type