PerceptMesh | index /scratch/srkenno/code/TPLs_src/Trilinos/packages/stk/stk_percept/build/build.dir/packages/PyTrilinos/src/stk/PyPercept/PerceptMesh.py

`PyPercept is the Python interface for the Trilinos STK Percept package.
The following are examples of the actual PyPercept Python interface:
##################################################################################################################
Case 1: Norm of the difference of an Exact Solution and a Mesh Field
pMesh = PerceptMesh() #Create a PerceptMesh database
#Specify the geometric hex mesh to be a 3x3x3 box between 0,0,0 and 2,2,2
pMesh.new_mesh(GMeshSpec('3x3x3|bbox:0,0,0,2,2,2'))
field = pMesh.add_field('coordinates', 1) #Add a coordinates field
pMesh.commit() #Commits the mesh to the mesh database
input_array = numpy.array([1.0, 0.5, 0.5]) #Create numpy arrays to be evaluated
input_array_2 = numpy.array([1.0, 1.5, 1.5])
'
#Create a field function with a name, field base, and the mesh and the domain and co-domain dimensions
ff = FieldFunction('ff', field, pMesh, 3, 3)
ff.addAlias('myalias') #Define another name for the field function
ff_output = ff.evaluate(input_array) #Evaluate the field function with the given array
f2 = FieldFunction('f2', field, pMesh, 3, 3)
f2_output = f2.evaluate(input_array_2)
#Create a function from a string 'x+y+z', with a name, the domain and co-domain dimensions
sf = StringFunction('x+y+z', 'myname', 3, 1)
sf_output = sf.evaluate(input_array) #Evaluate the function with the given array
sf_diff = StringFunction('ff-f2', 'myname') #Create a function of the difference of the field functions
norm = L1Norm(pMesh.getBulkData()) #Create a norm object to evaluate the norm of the mesh field
value = norm.evaluate(ff) #Evaluate the norm
diffnorm = norm.evaluate(sf_diff) #Evaluate the norm of the difference of the exact solution and the mesh field
#Now use a helper function to evaluate the norm: eval_norm(bulkData, Function, int)
value1 = eval_norm(pMesh.getBulkData(), ff, 1)
diffnorm1 = eval_norm(pMesh.getBulkData(), sf_diff, 1)
#################################################################################################################
Case 2: Refine a mesh uniformly
pMesh = PerceptMesh()
pMesh.open('tet-mesh-brick-no-block.e') #Read an existing exodus file
uniform_refiner = Refiner(pMesh, TET4_TET4_8) #Create a refiner on the specified mesh of the specified pattern.
pMesh.commit()
i = 0
while i < 3:
uniform_refiner.doBreak() #Call the doBreak() method to refine the mesh
i = i + 1
pMesh.saveAs('tet-mesh-refined-3-times.e') #Save out the refined mesh
#################################################################################################################
Case 3: Norm of the difference of results from two separate simulations
subprocess.call('sierra aria -i tet_mesh.e -o result_0.e') #Run an external program from Python
pMesh = PerceptMesh()
pMesh.open('tet-mesh.e')
uniform_refiner = Refiner(pMesh, TET4_TET4_8)
pMesh.commit()
uniform_refiner.doBreak()
pMesh.saveAs('tet-mesh_refined.e')
subprocess.call('sierra aria -i tet_mesh_refined.e -o result_1.e')
pMesh_0 = PerceptMesh()
pMesh_1 = PerceptMesh()
pMesh_0.openReadOnly('result_0.e')
pMesh_1.openReadOnly('result_1.e')
ff_0 = Field_Function(pMesh_0)
ff_1 = Field_Function(pMesh_1)
diff = StringFunction('ff_0 - ff_1')
diffnorm = eval_norm(pMesh.getBulkData, diff, 2)
print 'diffnorm = ', diffnorm
#################################################################################################################`

Modules

``

_PerceptMesh |  |  |

Classes

``

__builtin__.object
  BeamFixture
  Bucket
  BucketLess
  BulkData
  FEMMetaData
  FieldBase
  FieldCreateOrder
  FieldRepository
  GenericFunction
    Function
      ConstantFunction
      ConstantFunctionVec
      FieldFunction
      MaxOfNodeValues
      StringFunction
  Gmesh_STKmesh_Fixture
  HeterogeneousFixture
  L1Norm
  L2Norm
  LInfNorm
  MDArray
  MDArrayString
  MeshTransformer
  Name
    GMeshSpec
  OpType
  Part
  PartLess
  PartOrdLess
  PerceptMesh
  QuadFixture_3
  QuadFixture_4
  RCPComp
  RCPConstComp
  RCPFunction
  Refiner
  STK_Adapt_Auto_Part
  Selector
  SierraPort
  SwigPyIterator
  To_Ptr
  UniformRefinerPatternBase
  WedgeFixture
  Writer
  WriterThrowSafe
  vectord
  vectorfieldbase
  vectori
    Dimensions
  vectorparts
  vectors
  vectorvs

class BeamFixture(__builtin__.object)
`` | `Use case with mixed element topologies and field relations to provide fast access to node field data from an element. copied from stk_mesh and modified C++ includes: BeamFixture.hpp`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ParallelMachine comm, bool doCommit = True) -> BeamFixture
  __init__(self, ParallelMachine comm) -> BeamFixture
  stk_classic::percept::BeamFixture::BeamFixture(stk_classic::ParallelMachine comm, bool
  doCommit=true)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

populate(self)
  `populate(self)
  void
  stk_classic::percept::BeamFixture::populate()`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

m_block_beam
  `BeamFixture_m_block_beam_get(BeamFixture self) -> Part`

m_bulkData
  `BeamFixture_m_bulkData_get(BeamFixture self) -> BulkData`

m_centroid_field
  `BeamFixture_m_centroid_field_get(BeamFixture self) -> VectorFieldType`

m_coordinates_field
  `BeamFixture_m_coordinates_field_get(BeamFixture self) -> VectorFieldType`

m_elem_rank
  `BeamFixture_m_elem_rank_get(BeamFixture self) -> EntityRank`

m_element_node_coordinates_field
  `BeamFixture_m_element_node_coordinates_field_get(BeamFixture self) -> ElementNodePointerFieldType`

m_metaData
  `BeamFixture_m_metaData_get(BeamFixture self) -> FEMMetaData`

m_spatial_dimension
  `BeamFixture_m_spatial_dimension_get(BeamFixture self) -> int`

m_temperature_field
  `BeamFixture_m_temperature_field_get(BeamFixture self) -> ScalarFieldType`

m_volume_field
  `BeamFixture_m_volume_field_get(BeamFixture self) -> ScalarFieldType`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_BeamFixture>
  `delete_BeamFixture(BeamFixture self)
  stk_classic::percept::BeamFixture::~BeamFixture()`

__swig_getmethods__ = {'m_block_beam': <built-in function BeamFixture_m_block_beam_get>, 'm_bulkData': <built-in function BeamFixture_m_bulkData_get>, 'm_centroid_field': <built-in function BeamFixture_m_centroid_field_get>, 'm_coordinates_field': <built-in function BeamFixture_m_coordinates_field_get>, 'm_elem_rank': <built-in function BeamFixture_m_elem_rank_get>, 'm_element_node_coordinates_field': <built-in function BeamFixture_m_element_node_coordinates_field_get>, 'm_metaData': <built-in function BeamFixture_m_metaData_get>, 'm_spatial_dimension': <built-in function BeamFixture_m_spatial_dimension_get>, 'm_temperature_field': <built-in function BeamFixture_m_temperature_field_get>, 'm_volume_field': <built-in function BeamFixture_m_volume_field_get>}

__swig_setmethods__ = {}

class Bucket(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::Bucket class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

allocation_size(self)
  `allocation_size(self) -> unsigned int`

assert_correct(self)
  `assert_correct(self) -> bool`

begin(self)
  `begin(self) -> iterator`

capacity(self)
  `capacity(self) -> size_t`

end(self)
  `end(self) -> iterator`

entity_rank(self)
  `entity_rank(self) -> unsigned int`

equivalent(self, *args)
  `equivalent(self, Bucket b) -> bool`

fast_field_data_location(self, *args)
  `fast_field_data_location(self, FieldBase field, unsigned int ordinal) -> unsigned char`

field_data_location(self, *args)
  `field_data_location(self, FieldBase field, Entity entity) -> unsigned char
  field_data_location(self, FieldBase field, unsigned int ordinal) -> unsigned char
  field_data_location(self, FieldBase field) -> unsigned char`

field_data_size(self, *args)
  `field_data_size(self, FieldBase field) -> unsigned int`

field_data_stride(self, *args)
  `field_data_stride(self, FieldBase field) -> stk_classic::mesh::FieldBase::Restriction::size_type`

key(self)
  `key(self) -> unsigned int`

member(self, *args)
  `member(self, Part arg0) -> bool`

member_all(self, *args)
  `member_all(self, PartVector arg0) -> bool
  member_all(self, OrdinalVector arg0) -> bool`

member_any(self, *args)
  `member_any(self, PartVector arg0) -> bool
  member_any(self, OrdinalVector arg0) -> bool`

mesh(self)
  `mesh(self) -> BulkData`

size(self)
  `size(self) -> size_t`

superset_part_ordinals(self)
  `superset_part_ordinals(self) -> std::pair<(p.q(const).unsigned int,p.q(const).unsigned int)>`

supersets(self, *args)
  `supersets(self, PartVector arg0)
  supersets(self, OrdinalVector arg0)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class BucketLess(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::BucketLess class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> BucketLess`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_BucketLess>
  `delete_BucketLess(BucketLess self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class BulkData(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::BulkData class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, MetaData mesh_meta_data, ParallelMachine parallel,
  unsigned int bucket_max_size = 1000, bool use_memory_pool = True) -> BulkData
  __init__(self, MetaData mesh_meta_data, ParallelMachine parallel,
  unsigned int bucket_max_size = 1000) -> BulkData
  __init__(self, MetaData mesh_meta_data, ParallelMachine parallel) -> BulkData`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

buckets(self, *args)
  `buckets(self, EntityRank rank) -> std::vector<(p.stk_classic::mesh::Bucket,std::allocator<(p.stk_classic::mesh::Bucket)>)>`

change_entity_id(self, *args)
  `change_entity_id(self, EntityId id, Entity entity)`

change_entity_owner(self, *args)
  `change_entity_owner(self, std::vector<(stk_classic::mesh::EntityProc,std::allocator<(stk_classic::mesh::EntityProc)>)> arg_change)`

change_entity_parts(self, *args)
  `change_entity_parts(self, Entity entity, PartVector add_parts, PartVector remove_parts = stk_classic::mesh::PartVector())
  change_entity_parts(self, Entity entity, PartVector add_parts)`

change_ghosting(self, *args)
  `change_ghosting(self, Ghosting ghosts, std::vector<(stk_classic::mesh::EntityProc,std::allocator<(stk_classic::mesh::EntityProc)>)> add_send,
  std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)> remove_receive)`

copy_entity_fields(self, *args)
  `copy_entity_fields(self, Entity src, Entity dest)`

create_ghosting(self, *args)
  `create_ghosting(self, string name) -> Ghosting`

declare_entity(self, *args)
  `declare_entity(self, EntityRank ent_rank, EntityId ent_id, PartVector parts) -> Entity`

declare_relation(self, *args)
  `declare_relation(self, Entity e_from, Entity e_to, RelationIdentifier local_id)
  declare_relation(self, Entity entity, std::vector<(stk_classic::mesh::Relation,std::allocator<(stk_classic::mesh::Relation)>)> rel)`

destroy_all_ghosting(self)
  `destroy_all_ghosting(self)`

destroy_entity(self, *args)
  `destroy_entity(self, Entity entity) -> bool`

destroy_relation(self, *args)
  `destroy_relation(self, Entity e_from, Entity e_to, RelationIdentifier local_id) -> bool`

entity_comm(self, *args)
  `entity_comm(self) -> std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)>
  entity_comm(self, EntityKey key) -> PairIterEntityComm
  entity_comm(self, EntityKey key, Ghosting sub) -> PairIterEntityComm`

entity_comm_clear(self, *args)
  `entity_comm_clear(self, EntityKey key)`

entity_comm_clear_ghosting(self, *args)
  `entity_comm_clear_ghosting(self, EntityKey key)`

entity_comm_erase(self, *args)
  `entity_comm_erase(self, EntityKey key, EntityCommInfo val) -> bool
  entity_comm_erase(self, EntityKey key, Ghosting ghost) -> bool`

entity_comm_insert(self, *args)
  `entity_comm_insert(self, EntityKey key, EntityCommInfo val) -> bool`

entity_comm_sharing(self, *args)
  `entity_comm_sharing(self, EntityKey key) -> PairIterEntityComm`

entity_comm_swap(self, *args)
  `entity_comm_swap(self, EntityKey key1, EntityKey key2)`

final_modification_end(self)
  `final_modification_end(self) -> bool`

generate_new_entities(self, *args)
  `generate_new_entities(self, std::vector<(size_t,std::allocator<(size_t)>)> requests,
  std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)> requested_entities)`

get_entity(self, *args)
  `get_entity(self, EntityRank entity_rank, EntityId entity_id) -> Entity
  get_entity(self, EntityKey key) -> Entity`

ghostings(self)
  `ghostings(self) -> std::vector<(p.stk_classic::mesh::Ghosting,std::allocator<(p.stk_classic::mesh::Ghosting)>)>`

mesh_meta_data(self)
  `mesh_meta_data(self) -> MetaData`

modification_begin(self)
  `modification_begin(self) -> bool`

modification_end(self)
  `modification_end(self) -> bool`

optimize_buckets_at_modification_end(self, *args)
  `optimize_buckets_at_modification_end(self, bool b)`

parallel(self)
  `parallel(self) -> ParallelMachine`

parallel_rank(self)
  `parallel_rank(self) -> unsigned int`

parallel_size(self)
  `parallel_size(self) -> unsigned int`

shared_aura(self)
  `shared_aura(self) -> Ghosting`

synchronized_count(self)
  `synchronized_count(self) -> size_t`

synchronized_state(self)
  `synchronized_state(self) -> BulkDataSyncState`

update_field_data_states(self)
  `update_field_data_states(self)`

Static methods defined here:

get(*args)
  `get(Bucket bucket) -> BulkData
  get(Entity entity) -> BulkData
  get(Ghosting ghost) -> BulkData`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

MODIFIABLE = 1

SYNCHRONIZED = 2

__swig_destroy__ = <built-in function delete_BulkData>
  `delete_BulkData(BulkData self)`

__swig_getmethods__ = {'get': <function <lambda>>}

__swig_setmethods__ = {}

class ConstantFunction(Function)
`` | `Proxy of C++ stk_classic::percept::ConstantFunction class`

Method resolution order:
  ConstantFunction
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, double value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions(),
  unsigned int integration_order = 0) -> ConstantFunction
  __init__(self, double value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions()) -> ConstantFunction
  __init__(self, double value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions()) -> ConstantFunction
  __init__(self, double value, char name) -> ConstantFunction
  stk_classic::percept::ConstantFunction::ConstantFunction(double value, const
  char *name, Dimensions domain_dimensions=Dimensions(), Dimensions
  codomain_dimensions=Dimensions(), unsigned integration_order=0)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

getValue(self)
  `getValue(self) -> double
  double& stk_classic::percept::ConstantFunction::getValue()`

setValue(self, *args)
  `setValue(self, double v)
  void
  stk_classic::percept::ConstantFunction::setValue(double &v)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_ConstantFunction>
  `delete_ConstantFunction(ConstantFunction self)`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {}

Methods inherited from Function:

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual
  Teuchos::RCP<Function >
  stk_classic::percept::Function::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::Function::gradient(int
  spatialDim=3)`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods inherited from Function:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes inherited from Function:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class ConstantFunctionVec(Function)
`` | `Proxy of C++ stk_classic::percept::ConstantFunctionVec class`

Method resolution order:
  ConstantFunctionVec
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, vectord value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions(),
  unsigned int integration_order = 0) -> ConstantFunctionVec
  __init__(self, vectord value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions()) -> ConstantFunctionVec
  __init__(self, vectord value, char name, Dimensions domain_dimensions = stk_classic::percept::Dimensions()) -> ConstantFunctionVec
  __init__(self, vectord value, char name) -> ConstantFunctionVec
  stk_classic::percept::ConstantFunctionVec::ConstantFunctionVec(std::vector<
  double > &value, const char *name, Dimensions
  domain_dimensions=Dimensions(), Dimensions
  codomain_dimensions=Dimensions(), unsigned integration_order=0)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

getValue(self)
  `getValue(self) -> vectord
  std::vector<double>& stk_classic::percept::ConstantFunctionVec::getValue()`

setValue(self, *args)
  `setValue(self, vectord v)
  void stk_classic::percept::ConstantFunctionVec::setValue(std::vector< double >
  &v)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_ConstantFunctionVec>
  `delete_ConstantFunctionVec(ConstantFunctionVec self)`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {}

Methods inherited from Function:

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual
  Teuchos::RCP<Function >
  stk_classic::percept::Function::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::Function::gradient(int
  spatialDim=3)`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods inherited from Function:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes inherited from Function:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class Dimensions(vectori)
`` | `Proxy of C++ stk_classic::percept::Dimensions class`

Method resolution order:
  Dimensions
  vectori
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> Dimensions
  __init__(self, int i0) -> Dimensions
  __init__(self, int i0, int i1) -> Dimensions
  __init__(self, int i0, int i1, int i2) -> Dimensions
  stk_classic::percept::Dimensions::Dimensions(int i0, int i1, int i2)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_Dimensions>
  `delete_Dimensions(Dimensions self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

Methods inherited from vectori:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getitem__(self, *args)

__getslice__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors inherited from vectori:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class FEMMetaData(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::fem::FEMMetaData class`

Methods defined here:

FEM_initialize(self, *args)
  `FEM_initialize(self, size_t spatial_dimension, vectors in_entity_rank_names = std::vector< std::string >())
  FEM_initialize(self, size_t spatial_dimension)`

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> FEMMetaData
  __init__(self, size_t spatial_dimension, vectors in_entity_rank_names = std::vector< std::string >()) -> FEMMetaData
  __init__(self, size_t spatial_dimension) -> FEMMetaData`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

check_rank(self, *args)
  `check_rank(self, EntityRank rank) -> bool`

commit(self)
  `commit(self)`

declare_field_base(self, *args)
  `declare_field_base(self, string arg_name, DataTraits arg_traits, unsigned int arg_rank,
  shards::ArrayDimTag arg_dim_tags,
  unsigned int arg_num_states) -> FieldBase`

declare_field_restriction(self, *args)
  `declare_field_restriction(self, FieldBase arg_field, EntityRank arg_entity_rank, Part arg_part,
  unsigned int arg_stride, void arg_init_value = None)
  declare_field_restriction(self, FieldBase arg_field, EntityRank arg_entity_rank, Part arg_part,
  unsigned int arg_stride)`

declare_part(self, *args)
  `declare_part(self, string name, CellTopology cell_topology) -> Part
  declare_part(self, string p_name, EntityRank rank) -> Part
  declare_part(self, string p_name) -> Part`

declare_part_relation(self, *args)
  `declare_part_relation(self, Part root_part, relation_stencil_ptr stencil, Part target_part)`

declare_part_subset(self, *args)
  `declare_part_subset(self, Part superset, Part subset)`

edge_rank(self)
  `edge_rank(self) -> EntityRank`

element_rank(self)
  `element_rank(self) -> EntityRank`

entity_rank(self, *args)
  `entity_rank(self, string name) -> EntityRank`

entity_rank_count(self)
  `entity_rank_count(self) -> std::vector<(std::string,std::allocator<(std::string)>)>::size_type`

entity_rank_name(self, *args)
  `entity_rank_name(self, EntityRank in_entity_rank) -> string`

entity_rank_names(self)
  `entity_rank_names(self) -> vectors`

face_rank(self)
  `face_rank(self) -> EntityRank`

get_cell_topology(self, *args)
  `get_cell_topology(self, Part part) -> CellTopology
  get_cell_topology(self, string topology_name) -> CellTopology`

get_cell_topology_root_part(self, *args)
  `get_cell_topology_root_part(self, CellTopology cell_topology) -> Part`

get_entity_rank(self, *args)
  `get_entity_rank(self, CellTopology cell_topology) -> EntityRank`

get_field(self, *args)
  `get_field(self, string name) -> FieldBase`

get_field_relations(self)
  `get_field_relations(self) -> std::vector<(FieldRelation,std::allocator<(FieldRelation)>)>`

get_fields(self)
  `get_fields(self) -> FieldVector`

get_part(self, *args)
  `get_part(self, string p_name, char required_by = None) -> Part
  get_part(self, string p_name) -> Part
  get_part(self, unsigned int ord) -> Part`

get_parts(self)
  `get_parts(self) -> PartVector`

globally_shared_part(self)
  `globally_shared_part(self) -> Part`

is_FEM_initialized(self)
  `is_FEM_initialized(self) -> bool`

is_commit(self)
  `is_commit(self) -> bool`

is_valid_entity_rank(self, *args)
  `is_valid_entity_rank(self, EntityRank rank) -> bool`

locally_owned_part(self)
  `locally_owned_part(self) -> Part`

node_rank(self)
  `node_rank(self) -> EntityRank`

register_cell_topology(self, *args)
  `register_cell_topology(self, CellTopology cell_topology, EntityRank in_entity_rank)`

set_entity_rank_names(self, *args)
  `set_entity_rank_names(self, vectors in_entity_rank_names)`

side_rank(self)
  `side_rank(self) -> EntityRank`

spatial_dimension(self)
  `spatial_dimension(self) -> size_t`

universal_part(self)
  `universal_part(self) -> Part`

volume_rank(self)
  `volume_rank(self) -> EntityRank`

Static methods defined here:

get(*args)
  `get(MetaData meta) -> FEMMetaData
  get(Part part) -> FEMMetaData
  get(FieldBase field) -> FEMMetaData
  get(PropertyBase property) -> FEMMetaData
  get(BulkData bulk_data) -> FEMMetaData
  get(Bucket bucket) -> FEMMetaData
  get(Entity entity) -> FEMMetaData
  get(Ghosting ghost) -> FEMMetaData`

get_meta_data(*args)
  `get_meta_data(FEMMetaData fem_meta) -> MetaData`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

EDGE_RANK = 1

FACE_RANK = 2

INVALID_RANK = -1

NODE_RANK = 0

VOLUME_RANK = 3

__swig_destroy__ = <built-in function delete_FEMMetaData>
  `delete_FEMMetaData(FEMMetaData self)`

__swig_getmethods__ = {'get': <function <lambda>>, 'get_meta_data': <function <lambda>>}

__swig_setmethods__ = {}

class FieldBase(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::FieldBase class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

data_traits(self)
  `data_traits(self) -> DataTraits`

dimension_tags(self)
  `dimension_tags(self) -> shards::ArrayDimTag`

field_state(self, *args)
  `field_state(self, FieldState fstate) -> FieldBase`

get_initial_value(self, *args)
  `get_initial_value(self) -> void
  get_initial_value(self) -> void`

get_initial_value_num_bytes(self)
  `get_initial_value_num_bytes(self) -> unsigned int`

max_size(self, *args)
  `max_size(self, EntityRank entity_rank) -> unsigned int`

mesh_meta_data(self)
  `mesh_meta_data(self) -> MetaData`

mesh_meta_data_ordinal(self)
  `mesh_meta_data_ordinal(self) -> unsigned int`

name(self)
  `name(self) -> string`

number_of_states(self)
  `number_of_states(self) -> unsigned int`

rank(self)
  `rank(self) -> unsigned int`

restriction(self, *args)
  `restriction(self, unsigned int entity_rank, Part part) -> Restriction`

restrictions(self)
  `restrictions(self) -> RestrictionVector`

selector_restrictions(self)
  `selector_restrictions(self) -> RestrictionVector`

state(self)
  `state(self) -> FieldState`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_FieldBase>
  `delete_FieldBase(FieldBase self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class FieldCreateOrder(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::FieldCreateOrder class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> FieldCreateOrder
  __init__(self, string name, unsigned int entity_rank, vectori dimensions,
  Part part) -> FieldCreateOrder
  stk_classic::percept::FieldCreateOrder::FieldCreateOrder(const std::string
  name, const unsigned entity_rank, const std::vector< int > dimensions,
  const mesh::Part *part)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

m_dimensions
  `FieldCreateOrder_m_dimensions_get(FieldCreateOrder self) -> vectori`

m_entity_rank
  `FieldCreateOrder_m_entity_rank_get(FieldCreateOrder self) -> unsigned int`

m_name
  `FieldCreateOrder_m_name_get(FieldCreateOrder self) -> string`

m_part
  `FieldCreateOrder_m_part_get(FieldCreateOrder self) -> Part`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_FieldCreateOrder>
  `delete_FieldCreateOrder(FieldCreateOrder self)`

__swig_getmethods__ = {'m_dimensions': <built-in function FieldCreateOrder_m_dimensions_get>, 'm_entity_rank': <built-in function FieldCreateOrder_m_entity_rank_get>, 'm_name': <built-in function FieldCreateOrder_m_name_get>, 'm_part': <built-in function FieldCreateOrder_m_part_get>}

__swig_setmethods__ = {'m_part': <built-in function FieldCreateOrder_m_part_set>}

class FieldFunction(Function)

``

`Evaluate the function at this input point (or points) returning
value(s) in output_field_values
In the following, the arrays are dimensioned using the notation (from
Intrepid's doc):
[C] - num. integration domains (cells/elements) [F] - num. Intrepid
"fields" (number of bases within an element == num. nodes typically)
[P] - num. integration (or interpolation) points within the element
[D] - spatial dimension [D1], [D2] - spatial dimension
Locally, we introduce this notation:
[DOF] - number of degrees-of-freedom per node of the interpolated stk
Field. For example, a vector field in 3D has [DOF] = 3
C++ includes: FieldFunction.hpp
`

Method resolution order:
  FieldFunction
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, char name, FieldBase field, PerceptMesh mesh, int domain_dimension = 3,
  int codomain_dimension = 1,
  SearchType searchType = SIMPLE_SEARCH, unsigned int integration_order = 0) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh mesh, int domain_dimension = 3,
  int codomain_dimension = 1,
  SearchType searchType = SIMPLE_SEARCH) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh mesh, int domain_dimension = 3,
  int codomain_dimension = 1) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh mesh, int domain_dimension = 3) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh mesh) -> FieldFunction
  __init__(self, char name, FieldBase field, BulkData bulk, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions(),
  SearchType searchType = SIMPLE_SEARCH,
  unsigned int integration_order = 0) -> FieldFunction
  __init__(self, char name, FieldBase field, BulkData bulk, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions(),
  SearchType searchType = SIMPLE_SEARCH) -> FieldFunction
  __init__(self, char name, FieldBase field, BulkData bulk, Dimensions domain_dimensions = stk_classic::percept::Dimensions(),
  Dimensions codomain_dimensions = stk_classic::percept::Dimensions()) -> FieldFunction
  __init__(self, char name, FieldBase field, BulkData bulk, Dimensions domain_dimensions = stk_classic::percept::Dimensions()) -> FieldFunction
  __init__(self, char name, FieldBase field, BulkData bulk) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh eMesh, Dimensions domain_dimensions,
  Dimensions codomain_dimensions,
  SearchType searchType = SIMPLE_SEARCH,
  unsigned int integration_order = 0) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh eMesh, Dimensions domain_dimensions,
  Dimensions codomain_dimensions,
  SearchType searchType = SIMPLE_SEARCH) -> FieldFunction
  __init__(self, char name, FieldBase field, PerceptMesh eMesh, Dimensions domain_dimensions,
  Dimensions codomain_dimensions) -> FieldFunction
  stk_classic::percept::FieldFunction::FieldFunction(const char *name,
  mesh::FieldBase *field, PerceptMesh &eMesh, Dimensions
  domain_dimensions, Dimensions codomain_dimensions, SearchType
  searchType=SIMPLE_SEARCH, unsigned integration_order=0)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual Teuchos::RCP<Function >
  stk_classic::percept::FieldFunction::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

getFoundOnLocalOwnedPart(self)
  `getFoundOnLocalOwnedPart(self) -> bool
  bool
  stk_classic::percept::FieldFunction::getFoundOnLocalOwnedPart()`

get_bulk_data(self)
  `get_bulk_data(self) -> BulkData
  mesh::BulkData * stk_classic::percept::FieldFunction::get_bulk_data()`

get_field(self)
  `get_field(self) -> FieldBase
  mesh::FieldBase * stk_classic::percept::FieldFunction::get_field()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::FieldFunction::gradient(int
  spatialDim=3)`

interpolateFrom(self, *args)
  `interpolateFrom(self, Function function)
  void stk_classic::percept::FieldFunction::interpolateFrom(Function &function)
  for each node in the codomain, evaluate the function_to_interpolate's
  function, assign to the codomain field`

localEvaluation(self, *args)
  `localEvaluation(self, MDArray _in, double time_value_optional = 0.0)
  localEvaluation(self, MDArray _in)
  void stk_classic::percept::FieldFunction::localEvaluation(MDArray &in, MDArray
  &out, double time_value_optional=0.0)`

setup_searcher(self, *args)
  `setup_searcher(self, int D_)
  void stk_classic::percept::FieldFunction::setup_searcher(int D_)`

Data descriptors defined here:

m_parallelEval

Data and other attributes defined here:

SIMPLE_SEARCH = 0

STK_SEARCH = 1

__swig_destroy__ = <built-in function delete_FieldFunction>
  `delete_FieldFunction(FieldFunction self)
  stk_classic::percept::FieldFunction::~FieldFunction()`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'm_parallelEval': <built-in function FieldFunction_m_parallelEval_get>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {'m_parallelEval': <built-in function FieldFunction_m_parallelEval_set>}

Methods inherited from Function:

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods inherited from Function:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes inherited from Function:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class FieldRepository(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::impl::FieldRepository class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> FieldRepository`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

declare_field(self, *args)
  `declare_field(self, string arg_name, DataTraits arg_traits, unsigned int arg_rank,
  shards::ArrayDimTag arg_dim_tags,
  unsigned int arg_num_states, MetaData arg_meta_data) -> FieldBase`

declare_field_restriction(self, *args)
  `declare_field_restriction(self, char arg_method, FieldBase arg_field, unsigned int arg_entity_rank,
  Part arg_part, PartVector arg_all_parts,
  unsigned int arg_stride, void arg_init_value = None)
  declare_field_restriction(self, char arg_method, FieldBase arg_field, unsigned int arg_entity_rank,
  Part arg_part, PartVector arg_all_parts,
  unsigned int arg_stride)
  declare_field_restriction(self, char arg_method, FieldBase arg_field, unsigned int arg_entity_rank,
  Selector arg_selector, PartVector arg_all_parts,
  unsigned int arg_stride,
  void arg_init_value = None)
  declare_field_restriction(self, char arg_method, FieldBase arg_field, unsigned int arg_entity_rank,
  Selector arg_selector, PartVector arg_all_parts,
  unsigned int arg_stride)`

get_field(self, *args)
  `get_field(self, char arg_method, string arg_name, DataTraits arg_traits,
  unsigned int arg_rank, shards::ArrayDimTag arg_dim_tags,
  unsigned int arg_num_states) -> FieldBase`

get_fields(self)
  `get_fields(self) -> FieldVector`

verify_and_clean_restrictions(self, *args)
  `verify_and_clean_restrictions(self, char arg_method, Part superset, Part subset, PartVector arg_all_parts)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_FieldRepository>
  `delete_FieldRepository(FieldRepository self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class Function(GenericFunction)
`` | `Proxy of C++ stk_classic::percept::Function class`

Method resolution order:
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual
  Teuchos::RCP<Function >
  stk_classic::percept::Function::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::Function::gradient(int
  spatialDim=3)`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods defined here:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes defined here:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

__swig_destroy__ = <built-in function delete_Function>
  `delete_Function(Function self)`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {}

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class GMeshSpec(Name)
`` | `Proxy of C++ stk_classic::percept::GMeshSpec class`

Method resolution order:
  GMeshSpec
  Name
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, string name) -> GMeshSpec
  stk_classic::percept::GMeshSpec::GMeshSpec(const std::string &name)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_GMeshSpec>
  `delete_GMeshSpec(GMeshSpec self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

Methods inherited from Name:

getName(self)
  `getName(self) -> string
  const
  std::string& stk_classic::percept::Name::getName() const`

Data descriptors inherited from Name:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class GenericFunction(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::GenericFunction class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods defined here:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_GenericFunction>
  `delete_GenericFunction(GenericFunction self)
  virtual stk_classic::percept::GenericFunction::~GenericFunction()`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>}

__swig_setmethods__ = {}

class Gmesh_STKmesh_Fixture(__builtin__.object)
`` | `Proxy of C++ stk_classic::io::util::Gmesh_STKmesh_Fixture class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ParallelMachine comm, string gmesh_spec) -> Gmesh_STKmesh_Fixture`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

commit(self)
  `commit(self)`

getBulkData(self)
  `getBulkData(self) -> BulkData`

getElemCount(self)
  `getElemCount(self) -> size_t`

getFEMMetaData(self)
  `getFEMMetaData(self) -> FEMMetaData`

getMetaData(self)
  `getMetaData(self) -> MetaData`

getNodeCount(self)
  `getNodeCount(self) -> size_t`

getSideCount(self)
  `getSideCount(self) -> size_t`

getSideParts(self)
  `getSideParts(self) -> PartVector`

getSidesetNames(self)
  `getSidesetNames(self) -> vectors`

getSurfCoordInfo(self, *args)
  `getSurfCoordInfo(self, size_t surf_id) -> std::pair<(int,double)>`

getSurfElemCount(self, *args)
  `getSurfElemCount(self, size_t surf_id) -> size_t`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_Gmesh_STKmesh_Fixture>
  `delete_Gmesh_STKmesh_Fixture(Gmesh_STKmesh_Fixture self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class HeterogeneousFixture(__builtin__.object)
`` | `Use case with mixed element topologies and field relations to provide fast access to node field data from an element. copied from stk_mesh and modified C++ includes: HeterogeneousFixture.hpp`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ParallelMachine comm, bool doCommit = True, bool do_sidesets = False) -> HeterogeneousFixture
  __init__(self, ParallelMachine comm, bool doCommit = True) -> HeterogeneousFixture
  __init__(self, ParallelMachine comm) -> HeterogeneousFixture
  stk_classic::percept::HeterogeneousFixture::HeterogeneousFixture(stk_classic::ParallelMachine
  comm, bool doCommit=true, bool do_sidesets=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

populate(self)
  `populate(self)
  void stk_classic::percept::HeterogeneousFixture::populate()`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

m_block_hex
  `HeterogeneousFixture_m_block_hex_get(HeterogeneousFixture self) -> Part`

m_block_pyramid
  `HeterogeneousFixture_m_block_pyramid_get(HeterogeneousFixture self) -> Part`

m_block_tet
  `HeterogeneousFixture_m_block_tet_get(HeterogeneousFixture self) -> Part`

m_block_wedge
  `HeterogeneousFixture_m_block_wedge_get(HeterogeneousFixture self) -> Part`

m_bulkData
  `HeterogeneousFixture_m_bulkData_get(HeterogeneousFixture self) -> BulkData`

m_centroid_field
  `HeterogeneousFixture_m_centroid_field_get(HeterogeneousFixture self) -> VectorFieldType`

m_coordinates_field
  `HeterogeneousFixture_m_coordinates_field_get(HeterogeneousFixture self) -> VectorFieldType`

m_elem_rank
  `HeterogeneousFixture_m_elem_rank_get(HeterogeneousFixture self) -> EntityRank`

m_element_node_coordinates_field
  `HeterogeneousFixture_m_element_node_coordinates_field_get(HeterogeneousFixture self) -> ElementNodePointerFieldType`

m_metaData
  `HeterogeneousFixture_m_metaData_get(HeterogeneousFixture self) -> FEMMetaData`

m_sideset_quad
  `HeterogeneousFixture_m_sideset_quad_get(HeterogeneousFixture self) -> Part`

m_sideset_quad_subset
  `HeterogeneousFixture_m_sideset_quad_subset_get(HeterogeneousFixture self) -> Part`

m_sideset_tri
  `HeterogeneousFixture_m_sideset_tri_get(HeterogeneousFixture self) -> Part`

m_sideset_tri_subset
  `HeterogeneousFixture_m_sideset_tri_subset_get(HeterogeneousFixture self) -> Part`

m_spatial_dimension
  `HeterogeneousFixture_m_spatial_dimension_get(HeterogeneousFixture self) -> int`

m_temperature_field
  `HeterogeneousFixture_m_temperature_field_get(HeterogeneousFixture self) -> ScalarFieldType`

m_volume_field
  `HeterogeneousFixture_m_volume_field_get(HeterogeneousFixture self) -> ScalarFieldType`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_HeterogeneousFixture>
  `delete_HeterogeneousFixture(HeterogeneousFixture self)
  stk_classic::percept::HeterogeneousFixture::~HeterogeneousFixture()`

__swig_getmethods__ = {'m_block_hex': <built-in function HeterogeneousFixture_m_block_hex_get>, 'm_block_pyramid': <built-in function HeterogeneousFixture_m_block_pyramid_get>, 'm_block_tet': <built-in function HeterogeneousFixture_m_block_tet_get>, 'm_block_wedge': <built-in function HeterogeneousFixture_m_block_wedge_get>, 'm_bulkData': <built-in function HeterogeneousFixture_m_bulkData_get>, 'm_centroid_field': <built-in function HeterogeneousFixture_m_centroid_field_get>, 'm_coordinates_field': <built-in function HeterogeneousFixture_m_coordinates_field_get>, 'm_elem_rank': <built-in function HeterogeneousFixture_m_elem_rank_get>, 'm_element_node_coordinates_field': <built-in function HeterogeneousFixture_m_element_node_coordinates_field_get>, 'm_metaData': <built-in function HeterogeneousFixture_m_metaData_get>, ...}

__swig_setmethods__ = {'m_sideset_quad': <built-in function HeterogeneousFixture_m_sideset_quad_set>, 'm_sideset_quad_subset': <built-in function HeterogeneousFixture_m_sideset_quad_subset_set>, 'm_sideset_tri': <built-in function HeterogeneousFixture_m_sideset_tri_set>, 'm_sideset_tri_subset': <built-in function HeterogeneousFixture_m_sideset_tri_subset_set>}

class L1Norm(__builtin__.object)
`` | `This class will evaluate the L1 norm of a function.`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L1Norm
  __init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE) -> L1Norm
  __init__(self, BulkData bulkData, string partName) -> L1Norm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L1Norm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE) -> L1Norm
  __init__(self, BulkData bulkData, MDArrayString partNames) -> L1Norm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L1Norm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE) -> L1Norm
  __init__(self, BulkData bulkData, Part part = None) -> L1Norm
  __init__(self, BulkData bulkData) -> L1Norm
  stk_classic::percept::Norm<
  Power >::Norm(mesh::BulkData &bulkData, mesh::Selector *selector,
  TurboOption turboOpt=TURBO_NONE, bool is_surface_norm=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

error_check_is_surface_norm(self)
  `error_check_is_surface_norm(self)
  void stk_classic::percept::Norm< Power >::error_check_is_surface_norm()
  if a Selector is specified with part(s) that are not auto-declared,
  make sure all parts are of the same rank, and that m_is_surface_norm
  is set correctly (if not, warn...)`

evaluate(self, *args)
  `evaluate(self, Function integrand) -> double
  double
  stk_classic::percept::Norm< Power >::evaluate(Function &integrand)`

getCubDegree(self)
  `getCubDegree(self) -> unsigned int
  unsigned
  stk_classic::percept::Norm< Power >::getCubDegree()`

get_is_surface_norm(self)
  `get_is_surface_norm(self) -> bool
  bool
  stk_classic::percept::Norm< Power >::get_is_surface_norm()`

setCubDegree(self, *args)
  `setCubDegree(self, unsigned int cubDegree)
  void
  stk_classic::percept::Norm< Power >::setCubDegree(unsigned cubDegree)`

set_is_surface_norm(self, *args)
  `set_is_surface_norm(self, bool is_surface_norm)
  void
  stk_classic::percept::Norm< Power >::set_is_surface_norm(bool is_surface_norm)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_L1Norm>
  `delete_L1Norm(L1Norm self)
  virtual
  stk_classic::percept::Norm< Power >::~Norm()`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class L2Norm(__builtin__.object)
`` | `This class will evaluate the L2 norm of a function.`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L2Norm
  __init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE) -> L2Norm
  __init__(self, BulkData bulkData, string partName) -> L2Norm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L2Norm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE) -> L2Norm
  __init__(self, BulkData bulkData, MDArrayString partNames) -> L2Norm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> L2Norm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE) -> L2Norm
  __init__(self, BulkData bulkData, Part part = None) -> L2Norm
  __init__(self, BulkData bulkData) -> L2Norm
  stk_classic::percept::Norm<
  Power >::Norm(mesh::BulkData &bulkData, mesh::Selector *selector,
  TurboOption turboOpt=TURBO_NONE, bool is_surface_norm=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

error_check_is_surface_norm(self)
  `error_check_is_surface_norm(self)
  void stk_classic::percept::Norm< Power >::error_check_is_surface_norm()
  if a Selector is specified with part(s) that are not auto-declared,
  make sure all parts are of the same rank, and that m_is_surface_norm
  is set correctly (if not, warn...)`

evaluate(self, *args)
  `evaluate(self, Function integrand) -> double
  double
  stk_classic::percept::Norm< Power >::evaluate(Function &integrand)`

getCubDegree(self)
  `getCubDegree(self) -> unsigned int
  unsigned
  stk_classic::percept::Norm< Power >::getCubDegree()`

get_is_surface_norm(self)
  `get_is_surface_norm(self) -> bool
  bool
  stk_classic::percept::Norm< Power >::get_is_surface_norm()`

setCubDegree(self, *args)
  `setCubDegree(self, unsigned int cubDegree)
  void
  stk_classic::percept::Norm< Power >::setCubDegree(unsigned cubDegree)`

set_is_surface_norm(self, *args)
  `set_is_surface_norm(self, bool is_surface_norm)
  void
  stk_classic::percept::Norm< Power >::set_is_surface_norm(bool is_surface_norm)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_L2Norm>
  `delete_L2Norm(L2Norm self)
  virtual
  stk_classic::percept::Norm< Power >::~Norm()`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class LInfNorm(__builtin__.object)
`` | `This class will evaluate the L-inf norm of a function.`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> LInfNorm
  __init__(self, BulkData bulkData, string partName, TurboOption turboOpt = TURBO_NONE) -> LInfNorm
  __init__(self, BulkData bulkData, string partName) -> LInfNorm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> LInfNorm
  __init__(self, BulkData bulkData, MDArrayString partNames, TurboOption turboOpt = TURBO_NONE) -> LInfNorm
  __init__(self, BulkData bulkData, MDArrayString partNames) -> LInfNorm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE,
  bool is_surface_norm = False) -> LInfNorm
  __init__(self, BulkData bulkData, Part part = None, TurboOption turboOpt = TURBO_NONE) -> LInfNorm
  __init__(self, BulkData bulkData, Part part = None) -> LInfNorm
  __init__(self, BulkData bulkData) -> LInfNorm
  stk_classic::percept::Norm<
  Power >::Norm(mesh::BulkData &bulkData, mesh::Selector *selector,
  TurboOption turboOpt=TURBO_NONE, bool is_surface_norm=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

error_check_is_surface_norm(self)
  `error_check_is_surface_norm(self)
  void stk_classic::percept::Norm< Power >::error_check_is_surface_norm()
  if a Selector is specified with part(s) that are not auto-declared,
  make sure all parts are of the same rank, and that m_is_surface_norm
  is set correctly (if not, warn...)`

evaluate(self, *args)
  `evaluate(self, Function integrand) -> double
  double
  stk_classic::percept::Norm< Power >::evaluate(Function &integrand)`

getCubDegree(self)
  `getCubDegree(self) -> unsigned int
  unsigned
  stk_classic::percept::Norm< Power >::getCubDegree()`

get_is_surface_norm(self)
  `get_is_surface_norm(self) -> bool
  bool
  stk_classic::percept::Norm< Power >::get_is_surface_norm()`

setCubDegree(self, *args)
  `setCubDegree(self, unsigned int cubDegree)
  void
  stk_classic::percept::Norm< Power >::setCubDegree(unsigned cubDegree)`

set_is_surface_norm(self, *args)
  `set_is_surface_norm(self, bool is_surface_norm)
  void
  stk_classic::percept::Norm< Power >::set_is_surface_norm(bool is_surface_norm)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_LInfNorm>
  `delete_LInfNorm(LInfNorm self)
  virtual
  stk_classic::percept::Norm< Power >::~Norm()`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class MDArray(__builtin__.object)
`` | `Proxy of C++ Intrepid::FieldContainer<(double)> class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> MDArray
  __init__(self, MDArray right) -> MDArray
  __init__(self, int dim0) -> MDArray
  __init__(self, int dim0, int dim1) -> MDArray
  __init__(self, int dim0, int dim1, int dim2) -> MDArray
  __init__(self, int dim0, int dim1, int dim2, int dim3) -> MDArray
  __init__(self, int dim0, int dim1, int dim2, int dim3, int dim4) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions, Teuchos::ArrayView<(double)> data) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions, Teuchos::ArrayRCP<(double)> data) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions, double data, bool deep_copy = False,
  bool owns_mem = False) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions, double data, bool deep_copy = False) -> MDArray
  __init__(self, Teuchos::Array<(int)> dimensions, double data) -> MDArray
  __init__(self, shards::Array<(double,shards::NaturalOrder)> data,
  bool deep_copy = False, bool owns_mem = False) -> MDArray
  __init__(self, shards::Array<(double,shards::NaturalOrder)> data,
  bool deep_copy = False) -> MDArray
  __init__(self, shards::Array<(double,shards::NaturalOrder)> data) -> MDArray`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

clear(self)
  `clear(self)`

dimension(self, *args)
  `dimension(self, int whichDim) -> int`

getData(self)
  `getData(self) -> Teuchos::ArrayRCP<(double)>`

getEnumeration(self, *args)
  `getEnumeration(self, int i0) -> int
  getEnumeration(self, int i0, int i1) -> int
  getEnumeration(self, int i0, int i1, int i2) -> int
  getEnumeration(self, int i0, int i1, int i2, int i3) -> int
  getEnumeration(self, int i0, int i1, int i2, int i3, int i4) -> int
  getEnumeration(self, Teuchos::Array<(int)> multiIndex) -> int`

getMultiIndex(self, *args)
  `getMultiIndex(self, int i0, int valueEnum)
  getMultiIndex(self, int i0, int i1, int valueEnum)
  getMultiIndex(self, int i0, int i1, int i2, int valueEnum)
  getMultiIndex(self, int i0, int i1, int i2, int i3, int valueEnum)
  getMultiIndex(self, int i0, int i1, int i2, int i3, int i4, int valueEnum)`

getValue(self, *args)
  `getValue(self, Teuchos::Array<(int)> multiIndex) -> double`

initialize(self, value=0)
  `initialize(self, double value = 0)
  initialize(self)`

rank(self)
  `rank(self) -> int`

resize(self, *args)
  `resize(self, int dim0)
  resize(self, int dim0, int dim1)
  resize(self, int dim0, int dim1, int dim2)
  resize(self, int dim0, int dim1, int dim2, int dim3)
  resize(self, int dim0, int dim1, int dim2, int dim3, int dim4)
  resize(self, Teuchos::Array<(int)> newDimensions)
  resize(self, MDArray anotherContainer)
  resize(self, int numPoints, int numFields, EFunctionSpace spaceType,
  EOperator operatorType, int spaceDim)`

setValue(self, *args)
  `setValue(self, double dataValue, Teuchos::Array<(int)> multiIndex)
  setValue(self, double dataValue, int order)`

setValues(self, *args)
  `setValues(self, Teuchos::ArrayView<(double)> dataArray)
  setValues(self, double dataPtr, int numData)`

size(self)
  `size(self) -> int`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_MDArray>
  `delete_MDArray(MDArray self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class MDArrayString(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::MDArrayString class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> MDArrayString
  __init__(self, int dim) -> MDArrayString
  __init__(self, int dim0, int dim1) -> MDArrayString
  __init__(self, MDArrayString mda) -> MDArrayString
  stk_classic::percept::MDArrayString::MDArrayString(const MDArrayString &mda)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

dimension(self, *args)
  `dimension(self, int i1) -> int
  int
  stk_classic::percept::MDArrayString::dimension(int i1) const`

rank(self)
  `rank(self) -> int
  const int
  stk_classic::percept::MDArrayString::rank() const`

resize(self, *args)
  `resize(self, int dim)
  resize(self, int dim0, int dim1)
  void
  stk_classic::percept::MDArrayString::resize(int dim0, int dim1)`

setValues(self, *args)
  `setValues(self, string data)
  void
  stk_classic::percept::MDArrayString::setValues(std::string *data)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_MDArrayString>
  `delete_MDArrayString(MDArrayString self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class MaxOfNodeValues(Function)
`` | `Proxy of C++ stk_classic::percept::MaxOfNodeValues class`

Method resolution order:
  MaxOfNodeValues
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

m_integrand
  `MaxOfNodeValues_m_integrand_get(MaxOfNodeValues self) -> Function`

maxVal
  `MaxOfNodeValues_maxVal_get(MaxOfNodeValues self) -> vectord`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_MaxOfNodeValues>
  `delete_MaxOfNodeValues(MaxOfNodeValues self)`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'm_integrand': <built-in function MaxOfNodeValues_m_integrand_get>, 'maxVal': <built-in function MaxOfNodeValues_maxVal_get>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {'m_integrand': <built-in function MaxOfNodeValues_m_integrand_set>, 'maxVal': <built-in function MaxOfNodeValues_maxVal_set>}

Methods inherited from Function:

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual
  Teuchos::RCP<Function >
  stk_classic::percept::Function::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::Function::gradient(int
  spatialDim=3)`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods inherited from Function:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes inherited from Function:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class MeshTransformer(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::MeshTransformer class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> MeshTransformer
  __init__(self, Math::Matrix m) -> MeshTransformer
  stk_classic::percept::MeshTransformer::MeshTransformer(Math::Matrix &m)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_MeshTransformer>
  `delete_MeshTransformer(MeshTransformer self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class Name(__builtin__.object)

``

`Useful in other places where two strings are passed into a function or
constructor.
this is to avoid a common bug where the name of the String Function is
given instead of function_string, ie., first two args are accidentally
reversed - this is essentially a model of a "named argument", as
opposed to a positional one; of course, it is still only a hint
(though a strong one) to the user
C++ includes: Name.hpp
`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, string name) -> Name
  stk_classic::percept::Name::Name(const std::string name)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

getName(self)
  `getName(self) -> string
  const
  std::string& stk_classic::percept::Name::getName() const`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_Name>
  `delete_Name(Name self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class OpType(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::OpType class`

Methods defined here:

__eq__(self, *args)
  `__eq__(self, OpType opType) -> bool`

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self) -> OpType
  __init__(self, unsigned int part_id, unsigned int unary, unsigned int count,
  Op op = INVALID) -> OpType
  __init__(self, unsigned int part_id, unsigned int unary, unsigned int count) -> OpType`

__ne__(self, *args)
  `__ne__(self, OpType opType) -> bool`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

m_count
  `OpType_m_count_get(OpType self) -> unsigned short`

m_op
  `OpType_m_op_get(OpType self) -> Op`

m_part_id
  `OpType_m_part_id_get(OpType self) -> unsigned int`

m_unary
  `OpType_m_unary_get(OpType self) -> unsigned short`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_OpType>
  `delete_OpType(OpType self)`

__swig_getmethods__ = {'m_count': <built-in function OpType_m_count_get>, 'm_op': <built-in function OpType_m_op_get>, 'm_part_id': <built-in function OpType_m_part_id_get>, 'm_unary': <built-in function OpType_m_unary_get>}

__swig_setmethods__ = {'m_count': <built-in function OpType_m_count_set>, 'm_op': <built-in function OpType_m_op_set>, 'm_part_id': <built-in function OpType_m_part_id_set>, 'm_unary': <built-in function OpType_m_unary_set>}

class Part(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::Part class`

Methods defined here:

__eq__(self, *args)
  `__eq__(self, Part rhs) -> bool`

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__ne__(self, *args)
  `__ne__(self, Part rhs) -> bool`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

intersection_of(self)
  `intersection_of(self) -> PartVector`

mesh_meta_data(self)
  `mesh_meta_data(self) -> MetaData`

mesh_meta_data_ordinal(self)
  `mesh_meta_data_ordinal(self) -> unsigned int`

name(self)
  `name(self) -> string`

primary_entity_rank(self)
  `primary_entity_rank(self) -> unsigned int`

relations(self)
  `relations(self) -> std::vector<(PartRelation,std::allocator<(PartRelation)>)>`

subsets(self)
  `subsets(self) -> PartVector`

supersets(self)
  `supersets(self) -> PartVector`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class PartLess(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::PartLess class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> PartLess`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_PartLess>
  `delete_PartLess(PartLess self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class PartOrdLess(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::PartOrdLess class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> PartOrdLess`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_PartOrdLess>
  `delete_PartOrdLess(PartOrdLess self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class PerceptMesh(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::PerceptMesh class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, size_t spatialDimension = 3u, ParallelMachine comm = MPI_COMM_WORLD) -> PerceptMesh
  __init__(self, size_t spatialDimension = 3u) -> PerceptMesh
  __init__(self) -> PerceptMesh
  __init__(self, FEMMetaData metaData, BulkData bulkData, bool isCommitted = True) -> PerceptMesh
  __init__(self, FEMMetaData metaData, BulkData bulkData) -> PerceptMesh
  stk_classic::percept::PerceptMesh::PerceptMesh(const
  stk_classic::mesh::fem::FEMMetaData *metaData, stk_classic::mesh::BulkData *bulkData,
  bool isCommitted=true)
  Create a Mesh object that doesn't own its constituent FEMMetaData and
  BulkData, pointers to which are adopted by this constructor.`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

add_coordinate_state_fields(self)
  `add_coordinate_state_fields(self)
  void
  stk_classic::percept::PerceptMesh::add_coordinate_state_fields()
  add coordinate-like fields needed, for example, to use smoothing of
  geometry-projected refined meshes Must be called before commit()`

add_field(self, *args)
  `add_field(self, string name, unsigned int entity_rank, int vectorDimension = 0,
  string part_name = "universal_part") -> FieldBase
  add_field(self, string name, unsigned int entity_rank, int vectorDimension = 0) -> FieldBase
  add_field(self, string name, unsigned int entity_rank) -> FieldBase
  stk_classic::mesh::FieldBase* stk_classic::percept::PerceptMesh::add_field(const
  std::string &name, const unsigned entity_rank, int vectorDimension=0,
  const std::string part_name="universal_part")
  add a field to the mesh`

add_spacing_fields(self)
  `add_spacing_fields(self)
  void stk_classic::percept::PerceptMesh::add_spacing_fields()
  add spacing fields for having refinement obey the spacing (i.e.
  putting new nodes not at midpoint)`

close(self)
  `close(self)
  void
  stk_classic::percept::PerceptMesh::close()
  closes this mesh, deleting its data
  closes this mesh to further changes`

commit(self)
  `commit(self)
  void
  stk_classic::percept::PerceptMesh::commit()
  commits mesh - any operations done on a non-committed mesh, except to
  add fields will throw an exception`

copy_field(self, *args)
  `copy_field(self, FieldBase field_dest, FieldBase field_src)
  void
  stk_classic::percept::PerceptMesh::copy_field(stk_classic::mesh::FieldBase
  *field_dest, stk_classic::mesh::FieldBase *field_src)
  copy field data from one field (field_src) to another (field_dest)`

copy_field_state(self, *args)
  `copy_field_state(self, FieldBase field, unsigned int dest_state, unsigned int src_state)
  void stk_classic::percept::PerceptMesh::copy_field_state(stk_classic::mesh::FieldBase
  *field, unsigned dest_state, unsigned src_state)
  copy field state data from one state (src_state) to another
  (dest_state)`

dump_elements(self, partName='')
  `dump_elements(self, string partName = "")
  dump_elements(self)
  void
  stk_classic::percept::PerceptMesh::dump_elements(const std::string
  &partName="")
  print elements on the given part`

dump_elements_compact(self, partName='')
  `dump_elements_compact(self, string partName = "")
  dump_elements_compact(self)
  void
  stk_classic::percept::PerceptMesh::dump_elements_compact(const std::string
  &partName="")
  compact print of elements on the given part`

edge_rank(self)
  `edge_rank(self) -> EntityRank
  stk_classic::mesh::EntityRank stk_classic::percept::PerceptMesh::edge_rank() const
  Returns the edge rank which changes depending on spatial dimension.`

element_rank(self)
  `element_rank(self) -> EntityRank
  stk_classic::mesh::EntityRank stk_classic::percept::PerceptMesh::element_rank() const
  Returns the element rank which is always equal to spatial dimension.`

face_rank(self)
  `face_rank(self) -> EntityRank
  stk_classic::mesh::EntityRank stk_classic::percept::PerceptMesh::face_rank() const
  Returns the face rank which changes depending on spatial dimension.`

get_bulk_data(self)
  `get_bulk_data(self) -> BulkData
  stk_classic::mesh::BulkData * stk_classic::percept::PerceptMesh::get_bulk_data()
  get the low-level bulk data pointer from stk_mesh`

get_coordinates_field(self)
  `get_coordinates_field(self) -> VectorFieldType
  VectorFieldType*
  stk_classic::percept::PerceptMesh::get_coordinates_field()
  return a pointer to the field containing node coordinates`

get_current_database_step(self)
  `get_current_database_step(self) -> int
  int
  stk_classic::percept::PerceptMesh::get_current_database_step()
  return the current state of the Exodus database, 0 if not loaded yet
  (steps are 1-based in Exodus)`

get_current_database_time(self)
  `get_current_database_time(self) -> double
  double
  stk_classic::percept::PerceptMesh::get_current_database_time()
  return the current state of the Exodus database (time associated with
  current step)`

get_database_step_at_time(self, *args)
  `get_database_step_at_time(self, double time) -> int
  int
  stk_classic::percept::PerceptMesh::get_database_step_at_time(double time)
  return the step number closest to specified time, thus
  read_database_at_time(time) is equivalent to
  read_database_at_step(get_database_step_at_time(time))`

get_database_time_at_step(self, *args)
  `get_database_time_at_step(self, int step) -> double
  double
  stk_classic::percept::PerceptMesh::get_database_time_at_step(int step)
  return the state time associated with given step`

get_database_time_step_count(self)
  `get_database_time_step_count(self) -> int
  int
  stk_classic::percept::PerceptMesh::get_database_time_step_count()
  return the number of steps in the database`

get_element(self, *args)
  `get_element(self, EntityId element_id) -> Entity
  get_element(self, double x, double y, double z = 0, double t = 0) -> Entity
  get_element(self, double x, double y, double z = 0) -> Entity
  get_element(self, double x, double y) -> Entity
  stk_classic::mesh::Entity * stk_classic::percept::PerceptMesh::get_element(double x,
  double y, double z=0, double t=0)
  find and return pointer to element that contains given point - in
  parallel, check return for null (if null, element containing point is
  on another proc)
  find element that contains or is closest to given point`

get_entity(self, *args)
  `get_entity(self, EntityRank rank, EntityId id) -> Entity
  stk_classic::mesh::Entity*
  stk_classic::percept::PerceptMesh::get_entity(mesh::EntityRank rank, const
  mesh::EntityId id)
  get a pointer to an entity with given id`

get_fem_meta_data(self)
  `get_fem_meta_data(self) -> FEMMetaData
  stk_classic::mesh::fem::FEMMetaData *
  stk_classic::percept::PerceptMesh::get_fem_meta_data()
  get the low-level meta data pointer from stk_mesh`

get_field(self, *args)
  `get_field(self, string name) -> FieldBase
  stk_classic::mesh::FieldBase * stk_classic::percept::PerceptMesh::get_field(const
  std::string &name)`

get_field_data(self, *args)
  `get_field_data(self, FieldBase field, Entity entity, unsigned int ordinal = 0) -> double
  get_field_data(self, FieldBase field, Entity entity) -> double
  double stk_classic::percept::PerceptMesh::get_field_data(const
  stk_classic::mesh::FieldBase *field, const mesh::Entity *entity, unsigned
  ordinal=0)
  get the value of a field on the given entity; if a vector field, pass
  in the index of the vector required (ordinal)`

get_node(self, *args)
  `get_node(self, EntityId node_id) -> Entity
  get_node(self, double x, double y, double z = 0, double t = 0) -> Entity
  get_node(self, double x, double y, double z = 0) -> Entity
  get_node(self, double x, double y) -> Entity
  stk_classic::mesh::Entity * stk_classic::percept::PerceptMesh::get_node(double x,
  double y, double z=0, double t=0)
  find and return pointer to node closest to given point - in parallel,
  check return for null (if null, closest node is on another proc)`

get_node_field_data(self, *args)
  `get_node_field_data(self, FieldBase field, EntityId node_id, unsigned int ordinal = 0) -> double
  get_node_field_data(self, FieldBase field, EntityId node_id) -> double
  double
  stk_classic::percept::PerceptMesh::get_node_field_data(stk_classic::mesh::FieldBase
  *field, const mesh::EntityId node_id, unsigned ordinal=0)
  get the value of a field on the given node; if a vector field, pass in
  the index of the vector required (ordinal)`

get_number_edges(self)
  `get_number_edges(self) -> int
  int stk_classic::percept::PerceptMesh::get_number_edges()`

get_number_elements(self)
  `get_number_elements(self) -> int
  int stk_classic::percept::PerceptMesh::get_number_elements()`

get_number_elements_locally_owned(self)
  `get_number_elements_locally_owned(self) -> int
  int
  stk_classic::percept::PerceptMesh::get_number_elements_locally_owned()`

get_number_nodes(self)
  `get_number_nodes(self) -> int
  int stk_classic::percept::PerceptMesh::get_number_nodes()`

get_parallel_rank(self)
  `get_parallel_rank(self) -> unsigned int
  unsigned stk_classic::percept::PerceptMesh::get_parallel_rank()`

get_parallel_size(self)
  `get_parallel_size(self) -> unsigned int
  unsigned stk_classic::percept::PerceptMesh::get_parallel_size()`

get_part(self, *args)
  `get_part(self, string part_name) -> Part
  mesh::Part* stk_classic::percept::PerceptMesh::get_part(const std::string
  &part_name)
  get a pointer to a stk_mesh Part with the given name`

get_rank(self)
  `get_rank(self) -> unsigned int
  unsigned
  stk_classic::percept::PerceptMesh::get_rank()
  parallel rank`

get_spatial_dim(self)
  `get_spatial_dim(self) -> int
  int stk_classic::percept::PerceptMesh::get_spatial_dim()`

has_coordinate_state_fields(self)
  `has_coordinate_state_fields(self) -> bool
  bool
  stk_classic::percept::PerceptMesh::has_coordinate_state_fields()
  get number of coordinate field states needed`

new_mesh(self, *args)
  `new_mesh(self, GMeshSpec gmesh_spec)
  void
  stk_classic::percept::PerceptMesh::new_mesh(const GMeshSpec gmesh_spec)
  creates a new mesh using the GeneratedMesh fixture with spec
  Parameters:
  -----------
  gmesh_spec:`

new_mesh_read_only(self, *args)
  `new_mesh_read_only(self, GMeshSpec gmesh_spec)
  void stk_classic::percept::PerceptMesh::new_mesh_read_only(const GMeshSpec
  gmesh_spec)
  creates a new mesh using the GeneratedMesh fixture with spec
  Parameters:
  -----------
  gmesh_spec: Read: Only mode, no edits allowed`

nodal_field_axpby(self, *args)
  `nodal_field_axpby(self, double alpha, FieldBase field_x, double beta, FieldBase field_y)
  void stk_classic::percept::PerceptMesh::nodal_field_axpby(double alpha,
  stk_classic::mesh::FieldBase *field_x, double beta, stk_classic::mesh::FieldBase
  *field_y)
  axpby calculates: y = alpha*x + beta*y`

nodal_field_axpbypgz(self, *args)
  `nodal_field_axpbypgz(self, double alpha, FieldBase field_x, double beta, FieldBase field_y,
  double gamma, FieldBase field_z)
  void stk_classic::percept::PerceptMesh::nodal_field_axpbypgz(double alpha,
  stk_classic::mesh::FieldBase *field_x, double beta, stk_classic::mesh::FieldBase
  *field_y, double gamma, stk_classic::mesh::FieldBase *field_z)
  axpbypgz calculates: z = alpha*x + beta*y + gamma*z`

nodal_field_dot(self, *args)
  `nodal_field_dot(self, FieldBase field_x, FieldBase field_y) -> double
  double stk_classic::percept::PerceptMesh::nodal_field_dot(stk_classic::mesh::FieldBase
  *field_x, stk_classic::mesh::FieldBase *field_y)
  dot calculates: x.y`

nodal_field_set_value(self, *args)
  `nodal_field_set_value(self, FieldBase field_x, double value = 0.0)
  nodal_field_set_value(self, FieldBase field_x)
  void
  stk_classic::percept::PerceptMesh::nodal_field_set_value(stk_classic::mesh::FieldBase
  *field_x, double value=0.0)
  set field to constant value`

nodal_field_state_axpby(self, *args)
  `nodal_field_state_axpby(self, FieldBase field, double alpha, unsigned int x_state,
  double beta, unsigned int y_state)
  void
  stk_classic::percept::PerceptMesh::nodal_field_state_axpby(stk_classic::mesh::FieldBase
  *field, double alpha, unsigned x_state, double beta, unsigned y_state)
  axpby calculates: y = alpha*x + beta*y`

nodal_field_state_axpbypgz(self, *args)
  `nodal_field_state_axpbypgz(self, FieldBase field, double alpha, unsigned int x_state,
  double beta, unsigned int y_state, double gamma,
  unsigned int z_state)
  void
  stk_classic::percept::PerceptMesh::nodal_field_state_axpbypgz(stk_classic::mesh::FieldBase
  *field, double alpha, unsigned x_state, double beta, unsigned y_state,
  double gamma, unsigned z_state)
  axpbypgz calculates: z = alpha*x + beta*y + gamma*z`

node_rank(self)
  `node_rank(self) -> EntityRank
  stk_classic::mesh::EntityRank stk_classic::percept::PerceptMesh::node_rank() const
  return the rank of a node`

open(self, *args)
  `open(self, string in_filename)
  void
  stk_classic::percept::PerceptMesh::open(const std::string &in_filename)
  reads but doesn't commit mesh, enabling edit`

open_read_only(self, *args)
  `open_read_only(self, string in_filename)
  void stk_classic::percept::PerceptMesh::open_read_only(const std::string
  &in_filename)
  reads and commits mesh, editing disabled`

print_entity(self, *args)
  `print_entity(self, Entity entity, FieldBase field = None)
  print_entity(self, Entity entity)
  void
  stk_classic::percept::PerceptMesh::print_entity(std::ostream &out, const
  stk_classic::mesh::Entity &entity, stk_classic::mesh::FieldBase *field=0)`

print_entity_compact(self, *args)
  `print_entity_compact(self, Entity entity, FieldBase field = None) -> string
  print_entity_compact(self, Entity entity) -> string
  std::string stk_classic::percept::PerceptMesh::print_entity_compact(const
  stk_classic::mesh::Entity &entity, stk_classic::mesh::FieldBase *field=0)
  shorter output for print_entity`

print_fields(self, header='')
  `print_fields(self, string header = "")
  print_fields(self)
  void
  stk_classic::percept::PerceptMesh::print_fields(std::string header="")
  print the fields defined on the mesh`

print_info(self, *args)
  `print_info(self, std::ostream stream, string header = "", int print_level = 0,
  bool do_endl = True)
  print_info(self, std::ostream stream, string header = "", int print_level = 0)
  print_info(self, std::ostream stream, string header = "")
  print_info(self, std::ostream stream)
  print_info(self, string header = "", int print_level = 0, bool do_endl = True)
  print_info(self, string header = "", int print_level = 0)
  print_info(self, string header = "")
  print_info(self)
  void
  stk_classic::percept::PerceptMesh::print_info(std::string header="", int
  print_level=0, bool do_endl=true)
  print number of parts and fields, and info on each`

read_database_at_step(self, *args)
  `read_database_at_step(self, int step)
  void
  stk_classic::percept::PerceptMesh::read_database_at_step(int step)
  set the current data in fields to the given Exodus step by reading
  from the database`

read_database_at_time(self, *args)
  `read_database_at_time(self, double time)
  void
  stk_classic::percept::PerceptMesh::read_database_at_time(double time)
  set the current data in fields to the given Exodus time by reading
  from the database (finds the closest step to the given time (no
  interpolation yet))`

remove_geometry_blocks_on_output(self, *args)
  `remove_geometry_blocks_on_output(self, string geometry_file_name)
  void
  stk_classic::percept::PerceptMesh::remove_geometry_blocks_on_output(std::string
  geometry_file_name)
  remove blocks in the mesh used solely for geometry association, during
  output of the mesh to Exodus.
  Parameters:
  -----------
  geometry_file_name: = name of the OpenNURBS file (*.3dm) containing
  the geometry info
  Only available when Percept is configured with
  STK_PERCEPT_HAS_GEOMETRY`

reopen(self, temp_file_name='percept_tmp.e')
  `reopen(self, string temp_file_name = "percept_tmp.e")
  reopen(self)
  void
  stk_classic::percept::PerceptMesh::reopen(const std::string
  temp_file_name="percept_tmp.e")
  reopens the mesh for editing - warning, this operation writes the mesh
  to a temp file then re-reads it and thus recreates the internal
  FEMMetaData and BulkData`

save_as(self, *args)
  `save_as(self, string out_filename)
  void
  stk_classic::percept::PerceptMesh::save_as(const std::string &out_filename)
  commits mesh if not committed and saves it in new file`

set_field_data(self, *args)
  `set_field_data(self, double value, FieldBase field, Entity entity, unsigned int ordinal = 0)
  set_field_data(self, double value, FieldBase field, Entity entity)
  void stk_classic::percept::PerceptMesh::set_field_data(double value, const
  stk_classic::mesh::FieldBase *field, const mesh::Entity *entity, unsigned
  ordinal=0)
  set the value of a field on the given entity; if a vector field, pass
  in the index of the vector required (ordinal)`

set_node_field_data(self, *args)
  `set_node_field_data(self, double value, FieldBase field, EntityId node_id, unsigned int ordinal = 0)
  set_node_field_data(self, double value, FieldBase field, EntityId node_id)
  void stk_classic::percept::PerceptMesh::set_node_field_data(double value,
  stk_classic::mesh::FieldBase *field, const mesh::EntityId node_id, unsigned
  ordinal=0)
  set the value of a field on the given node; if a vector field, pass in
  the index of the vector required (ordinal)`

set_proc_rank_field(self, proc_rank_field=None)
  `set_proc_rank_field(self, FieldBase proc_rank_field = None)
  set_proc_rank_field(self)
  void
  stk_classic::percept::PerceptMesh::set_proc_rank_field(stk_classic::mesh::FieldBase
  *proc_rank_field=0)
  set proc_rank on each element`

side_rank(self)
  `side_rank(self) -> EntityRank
  stk_classic::mesh::EntityRank stk_classic::percept::PerceptMesh::side_rank() const
  Returns the side rank which changes depending on spatial dimension.`

transform_mesh(self, *args)
  `transform_mesh(self, MDArray matrix)
  void stk_classic::percept::PerceptMesh::transform_mesh(Math::Matrix &matrix)
  transform mesh by a given 3x3 matrix`

Static methods defined here:

mesh_difference(*args)
  `mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg, bool _print = True,
  bool print_all_field_diffs = False) -> bool
  mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg, bool _print = True) -> bool
  mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg) -> bool`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

s_omit_part

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_PerceptMesh>
  `delete_PerceptMesh(PerceptMesh self)
  stk_classic::percept::PerceptMesh::~PerceptMesh()`

__swig_getmethods__ = {'mesh_difference': <function <lambda>>, 's_omit_part': <built-in function PerceptMesh_s_omit_part_get>}

__swig_setmethods__ = {'s_omit_part': <built-in function PerceptMesh_s_omit_part_set>}

class QuadFixture_3(__builtin__.object)
`` | `This class creates a tri mesh.`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ParallelMachine pm, unsigned int nx, unsigned int ny,
  bool generate_sidesets_in, bool debug_geom_side_sets_as_blocks_in = False) -> QuadFixture_3
  __init__(self, ParallelMachine pm, unsigned int nx, unsigned int ny,
  bool generate_sidesets_in) -> QuadFixture_3
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::QuadFixture(stk_classic::ParallelMachine pm, unsigned nx, unsigned ny, bool
  generate_sidesets_in, bool debug_geom_side_sets_as_blocks_in=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

elem(self, *args)
  `elem(self, unsigned int ix, unsigned int iy) -> Entity
  stk_classic::mesh::Entity* stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem(unsigned ix, unsigned iy) const`

elem_id(self, *args)
  `elem_id(self, unsigned int ix, unsigned int iy) -> EntityId
  stk_classic::mesh::EntityId stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem_id(unsigned ix, unsigned iy) const`

elem_ix_iy(self, *args)
  `elem_ix_iy(self, EntityId entity_id, unsigned int ix, unsigned int iy)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem_ix_iy(stk_classic::mesh::EntityId entity_id, unsigned &ix, unsigned
  &iy) const`

generate_mesh(self, *args)
  `generate_mesh(self)
  generate_mesh(self, std::vector<(stk_classic::mesh::EntityId,std::allocator<(stk_classic::mesh::EntityId)>)> element_ids_on_this_processor)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_mesh(std::vector< stk_classic::mesh::EntityId >
  &element_ids_on_this_processor)`

generate_sides_bulk(self, *args)
  `generate_sides_bulk(self, std::vector<(stk_classic::mesh::EntityId,std::allocator<(stk_classic::mesh::EntityId)>)> element_ids_on_this_processor)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_sides_bulk(std::vector< stk_classic::mesh::EntityId >
  &element_ids_on_this_processor)`

generate_sides_meta(self)
  `generate_sides_meta(self)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_sides_meta()`

node(self, *args)
  `node(self, unsigned int ix, unsigned int iy) -> Entity
  stk_classic::mesh::Entity* stk_classic::percept::QuadFixture< Scalar, Topology
  >::node(unsigned ix, unsigned iy) const`

node_id(self, *args)
  `node_id(self, unsigned int ix, unsigned int iy) -> EntityId
  stk_classic::mesh::EntityId stk_classic::percept::QuadFixture< Scalar, Topology
  >::node_id(unsigned ix, unsigned iy) const`

node_ix_iy(self, *args)
  `node_ix_iy(self, EntityId entity_id, unsigned int ix, unsigned int iy)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::node_ix_iy(stk_classic::mesh::EntityId entity_id, unsigned &ix, unsigned
  &iy) const`

set_bounding_box(self, *args)
  `set_bounding_box(self, double xmin, double xmax, double ymin, double ymax)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::set_bounding_box(double xmin, double xmax, double ymin, double
  ymax)`

Static methods defined here:

get_entity_rank_names(*args)
  `get_entity_rank_names(unsigned int dim) -> vectors`

Data descriptors defined here:

NX
  `QuadFixture_3_NX_get(QuadFixture_3 self) -> unsigned int`

NY
  `QuadFixture_3_NY_get(QuadFixture_3 self) -> unsigned int`

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

bulk_data
  `QuadFixture_3_bulk_data_get(QuadFixture_3 self) -> BulkData`

coord_field
  `QuadFixture_3_coord_field_get(QuadFixture_3 self) -> CoordFieldType`

debug_geom_side_sets_as_blocks
  `QuadFixture_3_debug_geom_side_sets_as_blocks_get(QuadFixture_3 self) -> bool`

generate_sidesets
  `QuadFixture_3_generate_sidesets_get(QuadFixture_3 self) -> bool`

meta_data
  `QuadFixture_3_meta_data_get(QuadFixture_3 self) -> FEMMetaData`

quad_part
  `QuadFixture_3_quad_part_get(QuadFixture_3 self) -> Part`

side_parts
  `QuadFixture_3_side_parts_get(QuadFixture_3 self) -> Part`

Data and other attributes defined here:

NodesPerElem = 3

__swig_destroy__ = <built-in function delete_QuadFixture_3>
  `delete_QuadFixture_3(QuadFixture_3 self)
  stk_classic::percept::QuadFixture< Scalar, Topology >::~QuadFixture()`

__swig_getmethods__ = {'NX': <built-in function QuadFixture_3_NX_get>, 'NY': <built-in function QuadFixture_3_NY_get>, 'bulk_data': <built-in function QuadFixture_3_bulk_data_get>, 'coord_field': <built-in function QuadFixture_3_coord_field_get>, 'debug_geom_side_sets_as_blocks': <built-in function QuadFixture_3_debug_geom_side_sets_as_blocks_get>, 'generate_sidesets': <built-in function QuadFixture_3_generate_sidesets_get>, 'get_entity_rank_names': <function <lambda>>, 'meta_data': <built-in function QuadFixture_3_meta_data_get>, 'quad_part': <built-in function QuadFixture_3_quad_part_get>, 'side_parts': <built-in function QuadFixture_3_side_parts_get>}

__swig_setmethods__ = {'debug_geom_side_sets_as_blocks': <built-in function QuadFixture_3_debug_geom_side_sets_as_blocks_set>, 'generate_sidesets': <built-in function QuadFixture_3_generate_sidesets_set>, 'side_parts': <built-in function QuadFixture_3_side_parts_set>}

class QuadFixture_4(__builtin__.object)
`` | `This class creates a quad mesh.`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ParallelMachine pm, unsigned int nx, unsigned int ny,
  bool generate_sidesets_in, bool debug_geom_side_sets_as_blocks_in = False) -> QuadFixture_4
  __init__(self, ParallelMachine pm, unsigned int nx, unsigned int ny,
  bool generate_sidesets_in) -> QuadFixture_4
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::QuadFixture(stk_classic::ParallelMachine pm, unsigned nx, unsigned ny, bool
  generate_sidesets_in, bool debug_geom_side_sets_as_blocks_in=false)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

elem(self, *args)
  `elem(self, unsigned int ix, unsigned int iy) -> Entity
  stk_classic::mesh::Entity* stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem(unsigned ix, unsigned iy) const`

elem_id(self, *args)
  `elem_id(self, unsigned int ix, unsigned int iy) -> EntityId
  stk_classic::mesh::EntityId stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem_id(unsigned ix, unsigned iy) const`

elem_ix_iy(self, *args)
  `elem_ix_iy(self, EntityId entity_id, unsigned int ix, unsigned int iy)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::elem_ix_iy(stk_classic::mesh::EntityId entity_id, unsigned &ix, unsigned
  &iy) const`

generate_mesh(self, *args)
  `generate_mesh(self)
  generate_mesh(self, std::vector<(stk_classic::mesh::EntityId,std::allocator<(stk_classic::mesh::EntityId)>)> element_ids_on_this_processor)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_mesh(std::vector< stk_classic::mesh::EntityId >
  &element_ids_on_this_processor)`

generate_sides_bulk(self, *args)
  `generate_sides_bulk(self, std::vector<(stk_classic::mesh::EntityId,std::allocator<(stk_classic::mesh::EntityId)>)> element_ids_on_this_processor)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_sides_bulk(std::vector< stk_classic::mesh::EntityId >
  &element_ids_on_this_processor)`

generate_sides_meta(self)
  `generate_sides_meta(self)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::generate_sides_meta()`

node(self, *args)
  `node(self, unsigned int ix, unsigned int iy) -> Entity
  stk_classic::mesh::Entity* stk_classic::percept::QuadFixture< Scalar, Topology
  >::node(unsigned ix, unsigned iy) const`

node_id(self, *args)
  `node_id(self, unsigned int ix, unsigned int iy) -> EntityId
  stk_classic::mesh::EntityId stk_classic::percept::QuadFixture< Scalar, Topology
  >::node_id(unsigned ix, unsigned iy) const`

node_ix_iy(self, *args)
  `node_ix_iy(self, EntityId entity_id, unsigned int ix, unsigned int iy)
  void
  stk_classic::percept::QuadFixture< Scalar, Topology
  >::node_ix_iy(stk_classic::mesh::EntityId entity_id, unsigned &ix, unsigned
  &iy) const`

set_bounding_box(self, *args)
  `set_bounding_box(self, double xmin, double xmax, double ymin, double ymax)
  void stk_classic::percept::QuadFixture< Scalar, Topology
  >::set_bounding_box(double xmin, double xmax, double ymin, double
  ymax)`

Static methods defined here:

get_entity_rank_names(*args)
  `get_entity_rank_names(unsigned int dim) -> vectors`

Data descriptors defined here:

NX
  `QuadFixture_4_NX_get(QuadFixture_4 self) -> unsigned int`

NY
  `QuadFixture_4_NY_get(QuadFixture_4 self) -> unsigned int`

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

bulk_data
  `QuadFixture_4_bulk_data_get(QuadFixture_4 self) -> BulkData`

coord_field
  `QuadFixture_4_coord_field_get(QuadFixture_4 self) -> CoordFieldType`

debug_geom_side_sets_as_blocks
  `QuadFixture_4_debug_geom_side_sets_as_blocks_get(QuadFixture_4 self) -> bool`

generate_sidesets
  `QuadFixture_4_generate_sidesets_get(QuadFixture_4 self) -> bool`

meta_data
  `QuadFixture_4_meta_data_get(QuadFixture_4 self) -> FEMMetaData`

quad_part
  `QuadFixture_4_quad_part_get(QuadFixture_4 self) -> Part`

side_parts
  `QuadFixture_4_side_parts_get(QuadFixture_4 self) -> Part`

Data and other attributes defined here:

NodesPerElem = 4

__swig_destroy__ = <built-in function delete_QuadFixture_4>
  `delete_QuadFixture_4(QuadFixture_4 self)
  stk_classic::percept::QuadFixture< Scalar, Topology >::~QuadFixture()`

__swig_getmethods__ = {'NX': <built-in function QuadFixture_4_NX_get>, 'NY': <built-in function QuadFixture_4_NY_get>, 'bulk_data': <built-in function QuadFixture_4_bulk_data_get>, 'coord_field': <built-in function QuadFixture_4_coord_field_get>, 'debug_geom_side_sets_as_blocks': <built-in function QuadFixture_4_debug_geom_side_sets_as_blocks_get>, 'generate_sidesets': <built-in function QuadFixture_4_generate_sidesets_get>, 'get_entity_rank_names': <function <lambda>>, 'meta_data': <built-in function QuadFixture_4_meta_data_get>, 'quad_part': <built-in function QuadFixture_4_quad_part_get>, 'side_parts': <built-in function QuadFixture_4_side_parts_get>}

__swig_setmethods__ = {'debug_geom_side_sets_as_blocks': <built-in function QuadFixture_4_debug_geom_side_sets_as_blocks_set>, 'generate_sidesets': <built-in function QuadFixture_4_generate_sidesets_set>, 'side_parts': <built-in function QuadFixture_4_side_parts_set>}

class RCPComp(__builtin__.object)
`` | `Proxy of C++ Teuchos::RCPComp class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> RCPComp`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_RCPComp>
  `delete_RCPComp(RCPComp self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class RCPConstComp(__builtin__.object)
`` | `Proxy of C++ Teuchos::RCPConstComp class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> RCPConstComp`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_RCPConstComp>
  `delete_RCPConstComp(RCPConstComp self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class RCPFunction(__builtin__.object)
`` | `Proxy of C++ Teuchos::RCP<(stk_classic::percept::Function)> class`

Methods defined here:

__deref__(self)
  `__deref__(self) -> Function`

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, ENull null_arg = null) -> RCPFunction
  __init__(self) -> RCPFunction
  __init__(self, Function p, bool has_ownership = True) -> RCPFunction
  __init__(self, Function p) -> RCPFunction
  __init__(self, RCPFunction r_ptr) -> RCPFunction
  __init__(self, Function p, ERCPWeakNoDealloc arg1) -> RCPFunction
  __init__(self, Function p, ERCPUndefinedWeakNoDealloc arg1) -> RCPFunction
  __init__(self, Function p, RCPNodeHandle node) -> RCPFunction`

__ref__(self)
  `__ref__(self) -> Function`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

access_private_node(self)
  `access_private_node(self) -> RCPNodeHandle`

access_private_ptr(self)
  `access_private_ptr(self) -> Function`

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in, MDArray out) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

assert_not_null(self)
  `assert_not_null(self) -> RCPFunction`

assert_valid_ptr(self)
  `assert_valid_ptr(self) -> RCPFunction`

count(self)
  `count(self) -> int`

create_strong(self)
  `create_strong(self) -> RCPFunction`

create_weak(self)
  `create_weak(self) -> RCPFunction`

debug_assert_not_null(self)
  `debug_assert_not_null(self) -> RCPFunction`

debug_assert_valid_ptr(self)
  `debug_assert_valid_ptr(self) -> RCPFunction`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  virtual
  Teuchos::RCP<Function >
  stk_classic::percept::Function::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

get(self)
  `get(self) -> Function`

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getConst(self)
  `getConst(self) -> Teuchos::RCP<(q(const).stk_classic::percept::Function)>`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

getNewMDArray(self, *args)
  `getNewMDArray(self, Dimensions dims) -> MDArray`

getRawPtr(self)
  `getRawPtr(self) -> Function`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  virtual
  Teuchos::RCP<Function > stk_classic::percept::Function::gradient(int
  spatialDim=3)`

has_ownership(self)
  `has_ownership(self) -> bool`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

is_null(self)
  `is_null(self) -> bool`

is_valid_ptr(self)
  `is_valid_ptr(self) -> bool`

nonconst_access_private_node(self)
  `nonconst_access_private_node(self) -> RCPNodeHandle`

ptr(self)
  `ptr(self) -> Teuchos::Ptr<(stk_classic::percept::Function)>`

release(self)
  `release(self) -> Teuchos::Ptr<(stk_classic::percept::Function)>`

reset(self)
  `reset(self)`

setCodomainDimDefault(self, *args)
  `setCodomainDimDefault(self, unsigned int codomainDim)`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

setIntegrationOrderDefault(self, *args)
  `setIntegrationOrderDefault(self, unsigned int integration_order)`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

setSpatialDimDefault(self, *args)
  `setSpatialDimDefault(self, unsigned int spatialDim)`

set_has_ownership(self)
  `set_has_ownership(self)`

strength(self)
  `strength(self) -> ERCPStrength`

strong_count(self)
  `strong_count(self) -> int`

swap(self, *args)
  `swap(self, RCPFunction r_ptr)`

total_count(self)
  `total_count(self) -> int`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

weak_count(self)
  `weak_count(self) -> int`

Data descriptors defined here:

Identity
  `RCPFunction_Identity_get(RCPFunction self) -> Function`

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_RCPFunction>
  `delete_RCPFunction(RCPFunction self)`

__swig_getmethods__ = {'Identity': <built-in function RCPFunction_Identity_get>}

__swig_setmethods__ = {}

class Refiner(__builtin__.object)
`` | `e.g. UniformRefiner<shards::Hex<8>, shards::Tet<4> > C++ includes: Refiner.hpp`

Methods defined here:

__basePatterns__(self)
  `__basePatterns__(self)
  The following is a list of patterns that may be used to create a Refiner object:
  BEAM2_BEAM2_2
  BEAM2_BEAM3_1
  BEAM3_BEAM3_2
  HEX20_HEX20_8
  HEX27_HEX27_8
  HEX8_HEX20_1
  HEX8_HEX27_1
  HEX8_HEX8_8
  HEX8_TET4_24
  HEX8_TET4_6_12
  LINE2_LINE2_2
  LINE3_LINE3_2
  QUAD4_QUAD4_4
  QUAD4_QUAD4_4_OLD
  QUAD4_QUAD4_4_SIERRA
  QUAD4_QUAD8_1
  QUAD4_QUAD9_1
  QUAD4_TRI3_2
  QUAD4_TRI3_4
  QUAD4_TRI3_6
  QUAD8_QUAD8_4
  QUAD9_QUAD9_4
  SHELLLINE2_SHELLLINE2_2
  SHELLLINE3_SHELLLINE3_2
  SHELLLINE3_SHELLLINE3_2
  SHELLQUAD4_SHELLQUAD8_1
  SHELLQUAD8_SHELLQUAD8_4
  SHELLTRI3_SHELLTRI3_4
  SHELLTRI6_SHELLTRI6_4
  TET10_TET10_8
  TET4_TET10_1
  TET4_TET4_8
  TRI3_TRI3_4
  TRI3_TRI6_1
  TRI6_TRI6_4
  WEDGE15_WEDGE15_8
  WEDGE18_WEDGE18_8
  WEDGE6_WEDGE15_1
  WEDGE6_WEDGE18_1
  WEDGE6_WEDGE6_8`

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, PerceptMesh eMesh, UniformRefinerPatternBase bp, FieldBase proc_rank_field = None) -> Refiner
  __init__(self, PerceptMesh eMesh, UniformRefinerPatternBase bp) -> Refiner
  __init__(self, PerceptMesh eMesh, Pattern refine_type, FieldBase proc_rank_field = None) -> Refiner
  __init__(self, PerceptMesh eMesh, Pattern refine_type) -> Refiner
  stk_classic::adapt::Refiner::Refiner(percept::PerceptMesh &eMesh, Pattern
  refine_type, stk_classic::mesh::FieldBase *proc_rank_field=0)`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

check_db(self, msg='')
  `check_db(self, string msg = "")
  check_db(self)
  void
  stk_classic::adapt::Refiner::check_db(std::string msg="")`

check_sidesets(self, msg='')
  `check_sidesets(self, string msg = "")
  check_sidesets(self)
  void
  stk_classic::adapt::Refiner::check_sidesets(std::string msg="")`

check_sidesets_1(self, *args)
  `check_sidesets_1(self, string msg)
  void
  stk_classic::adapt::Refiner::check_sidesets_1(std::string msg)`

check_sidesets_2(self, *args)
  `check_sidesets_2(self, string msg)
  void
  stk_classic::adapt::Refiner::check_sidesets_2(std::string msg)`

connectSides(self, *args)
  `connectSides(self, Entity element, Entity side_elem, SidePartMap side_part_map = None) -> bool
  connectSides(self, Entity element, Entity side_elem) -> bool
  bool
  stk_classic::adapt::Refiner::connectSides(stk_classic::mesh::Entity *element,
  stk_classic::mesh::Entity *side_elem, SidePartMap *side_part_map=0)`

deleteParentElements(self)
  `deleteParentElements(self)
  void stk_classic::adapt::Refiner::deleteParentElements()
  Delete all elements that aren't child elements.`

doBreak(self)
  `doBreak(self)
  void
  stk_classic::adapt::Refiner::doBreak()
  FIXME add part info
  communicate all-to-all the new node creation information which also
  updates the node registry so it can be queried locally now for any
  ghost or non-ghost element
  Global element ops: here's where we e.g. connect the new elements by
  declaring new relations
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  Global node loop operations: this is where we perform ops like adding
  new nodes to the right parts, interpolating fields, etc.
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////`

fixElementSides2(self)
  `fixElementSides2(self)
  void
  stk_classic::adapt::Refiner::fixElementSides2()`

fixSides(self, *args)
  `fixSides(self, Entity parent)
  void
  stk_classic::adapt::Refiner::fixSides(stk_classic::mesh::Entity *parent)`

fix_side_sets_1(self)
  `fix_side_sets_1(self)
  void
  stk_classic::adapt::Refiner::fix_side_sets_1()`

fix_side_sets_2(self)
  `fix_side_sets_2(self)
  void
  stk_classic::adapt::Refiner::fix_side_sets_2()`

fix_side_sets_3(self, *args)
  `fix_side_sets_3(self, bool checkParentChild, SidePartMap side_part_map)
  void
  stk_classic::adapt::Refiner::fix_side_sets_3(bool checkParentChild,
  SidePartMap &side_part_map)`

getAlwaysInitializeNodeRegistry(self)
  `getAlwaysInitializeNodeRegistry(self) -> bool
  bool
  stk_classic::adapt::Refiner::getAlwaysInitializeNodeRegistry()`

getDoProgressMeter(self)
  `getDoProgressMeter(self) -> bool
  bool
  stk_classic::adapt::Refiner::getDoProgressMeter()`

getIgnoreSideSets(self)
  `getIgnoreSideSets(self) -> bool
  bool
  stk_classic::adapt::Refiner::getIgnoreSideSets()`

getMesh(self)
  `getMesh(self) -> PerceptMesh
  percept::PerceptMesh& stk_classic::adapt::Refiner::getMesh()`

getNodeRegistry(self)
  `getNodeRegistry(self) -> NodeRegistry
  NodeRegistry& stk_classic::adapt::Refiner::getNodeRegistry()`

getRefinementInfoByType(self)
  `getRefinementInfoByType(self) -> std::vector<(RefinementInfoByType,std::allocator<(RefinementInfoByType)>)>
  std::vector< RefinementInfoByType > &
  stk_classic::adapt::Refiner::getRefinementInfoByType()`

getRemoveGeometryBlocks(self)
  `getRemoveGeometryBlocks(self) -> bool
  bool stk_classic::adapt::Refiner::getRemoveGeometryBlocks()`

getRemoveOldElements(self)
  `getRemoveOldElements(self) -> bool
  bool stk_classic::adapt::Refiner::getRemoveOldElements()`

getSmoothGeometry(self)
  `getSmoothGeometry(self) -> bool
  bool
  stk_classic::adapt::Refiner::getSmoothGeometry()`

get_side_part_relations(self, *args)
  `get_side_part_relations(self, bool checkParentChild, SidePartMap side_part_map)
  void stk_classic::adapt::Refiner::get_side_part_relations(bool
  checkParentChild, SidePartMap &side_part_map)
  determine side part to elem part relations`

setAlwaysInitializeNodeRegistry(self, *args)
  `setAlwaysInitializeNodeRegistry(self, bool do_init)
  void
  stk_classic::adapt::Refiner::setAlwaysInitializeNodeRegistry(bool do_init)`

setDoProgressMeter(self, *args)
  `setDoProgressMeter(self, bool do_progress)
  void
  stk_classic::adapt::Refiner::setDoProgressMeter(bool do_progress)`

setGeometryFile(self, *args)
  `setGeometryFile(self, string file_name)
  void
  stk_classic::adapt::Refiner::setGeometryFile(std::string file_name)`

setIgnoreSideSets(self, *args)
  `setIgnoreSideSets(self, bool ignore_sidesets)
  void
  stk_classic::adapt::Refiner::setIgnoreSideSets(bool ignore_sidesets)`

setQueryPassOnly(self, *args)
  `setQueryPassOnly(self, bool doQueryOnly)
  void
  stk_classic::adapt::Refiner::setQueryPassOnly(bool doQueryOnly)`

setRemoveGeometryBlocks(self, *args)
  `setRemoveGeometryBlocks(self, bool do_remove)
  void stk_classic::adapt::Refiner::setRemoveGeometryBlocks(bool do_remove)`

setRemoveOldElements(self, *args)
  `setRemoveOldElements(self, bool do_remove)
  void stk_classic::adapt::Refiner::setRemoveOldElements(bool do_remove)`

setSmoothGeometry(self, *args)
  `setSmoothGeometry(self, bool do_smooth)
  void
  stk_classic::adapt::Refiner::setSmoothGeometry(bool do_smooth)`

unrefineAll(self)
  `unrefineAll(self)
  void
  stk_classic::adapt::Refiner::unrefineAll()`

unrefineTheseElements(self, *args)
  `unrefineTheseElements(self, ElementUnrefineCollection elements_to_unref)
  void
  stk_classic::adapt::Refiner::unrefineTheseElements(ElementUnrefineCollection
  &elements_to_unref)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_Refiner>
  `delete_Refiner(Refiner self)
  stk_classic::adapt::Refiner::~Refiner()`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class STK_Adapt_Auto_Part(__builtin__.object)
`` | `signifies a part that has been defined automatically during adaptivity C++ includes: UniformRefinerPattern.hpp`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> STK_Adapt_Auto_Part`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_STK_Adapt_Auto_Part>
  `delete_STK_Adapt_Auto_Part(STK_Adapt_Auto_Part self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class Selector(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::Selector class`

Methods defined here:

__eq__(self, *args)
  `__eq__(self, Selector rhs) -> bool`

__getattr__ lambda self, name

__iand__(self, *args)
  `__iand__(self, Selector selector) -> Selector`

__init__(self, *args)
  `__init__(self) -> Selector
  __init__(self, Part part) -> Selector`

__ior__(self, *args)
  `__ior__(self, Selector selector) -> Selector`

__ne__(self, *args)
  `__ne__(self, Selector rhs) -> bool`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

complement(self)
  `complement(self) -> Selector`

compoundAll(self)
  `compoundAll(self)`

get_ops(self)
  `get_ops(self) -> std::vector<(stk_classic::mesh::OpType,std::allocator<(stk_classic::mesh::OpType)>)>`

set_ops(self, *args)
  `set_ops(self, std::vector<(stk_classic::mesh::OpType,std::allocator<(stk_classic::mesh::OpType)>)> ops)`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_Selector>
  `delete_Selector(Selector self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class SierraPort(__builtin__.object)
`` | `Proxy of C++ stk_classic::adapt::SierraPort class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> SierraPort`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_SierraPort>
  `delete_SierraPort(SierraPort self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class StringFunction(Function)
`` | `Proxy of C++ stk_classic::percept::StringFunction class`

Method resolution order:
  StringFunction
  Function
  GenericFunction
  __builtin__.object

Methods defined here:

__add__(self, *args)
  `__add__(self, StringFunction rhs) -> StringFunction`

__div__(self, *args)
  `__div__(self, StringFunction rhs) -> StringFunction`

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, char function_string, Name name = stk_classic::percept::Name("noname"),
  int domain_dimension = 3, int codomain_dimension = 1,
  unsigned int integration_order = 0) -> StringFunction
  __init__(self, char function_string, Name name = stk_classic::percept::Name("noname"),
  int domain_dimension = 3, int codomain_dimension = 1) -> StringFunction
  __init__(self, char function_string, Name name = stk_classic::percept::Name("noname"),
  int domain_dimension = 3) -> StringFunction
  __init__(self, char function_string, Name name = stk_classic::percept::Name("noname")) -> StringFunction
  __init__(self, char function_string) -> StringFunction
  __init__(self, char function_string, Name name, Dimensions domain_dimensions,
  Dimensions codomain_dimensions, unsigned int integration_order = 0) -> StringFunction
  __init__(self, char function_string, Name name, Dimensions domain_dimensions,
  Dimensions codomain_dimensions) -> StringFunction
  __init__(self, StringFunction s) -> StringFunction
  stk_classic::percept::StringFunction::StringFunction(const StringFunction &s)`

__mul__(self, *args)
  `__mul__(self, StringFunction rhs) -> StringFunction`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__sub__(self, *args)
  `__sub__(self, StringFunction rhs) -> StringFunction`

derivative(self, *args)
  `derivative(self, MDArrayString deriv_spec) -> RCPFunction
  Teuchos::RCP< Function >
  stk_classic::percept::StringFunction::derivative(MDArrayString &deriv_spec)
  Return a function that is the derivative of this function. The
  derivative is specified as a rank-2 array of strings that specify what
  derivative to take and how many derivatives. For example,`

derivative_test(self, *args)
  `derivative_test(self, MDArrayString deriv_spec) -> RCPFunction
  Teuchos::RCP< Function >
  stk_classic::percept::StringFunction::derivative_test(MDArrayString
  &deriv_spec)`

derivative_test_fd(self, *args)
  `derivative_test_fd(self, MDArrayString deriv_spec, double eps = 1.e-6) -> RCPFunction
  derivative_test_fd(self, MDArrayString deriv_spec) -> RCPFunction
  Teuchos::RCP<
  Function >
  stk_classic::percept::StringFunction::derivative_test_fd(MDArrayString
  &deriv_spec, double eps=1.e-6)`

getFunctionString(self)
  `getFunctionString(self) -> string
  std::string stk_classic::percept::StringFunction::getFunctionString()`

gradient(self, spatialDim=3)
  `gradient(self, int spatialDim = 3) -> RCPFunction
  gradient(self) -> RCPFunction
  Teuchos::RCP< Function > stk_classic::percept::StringFunction::gradient(int
  spatialDim=3)`

resolve(self, *args)
  `resolve(self, stk_classic::expreval::VariableMap::iterator var_it)
  void
  stk_classic::percept::StringFunction::resolve(stk_classic::expreval::VariableMap::iterator
  &var_it)`

set_gradient_strings(self, *args)
  `set_gradient_strings(self, string gstring, int len)
  set_gradient_strings(self, MDArrayString gstring)
  void
  stk_classic::percept::StringFunction::set_gradient_strings(MDArrayString
  &gstring)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_StringFunction>
  `delete_StringFunction(StringFunction self)`

__swig_getmethods__ = {'getNewMDArray': <function <lambda>>, 'setCodomainDimDefault': <function <lambda>>, 'setIntegrationOrderDefault': <function <lambda>>, 'setSpatialDimDefault': <function <lambda>>}

__swig_setmethods__ = {}

Methods inherited from Function:

add_alias(self, *args)
  `add_alias(self, char alias) -> Function
  Function *
  stk_classic::percept::Function::add_alias(const char *alias)
  allow this function to have one or more aliases`

argsAreValid(self, *args)
  `argsAreValid(self, MDArray _in) -> bool
  bool
  stk_classic::percept::Function::argsAreValid(const MDArray &in, const MDArray
  &out)
  Verify that the last dimensions of
  Parameters:
  -----------
  in: and
  out: are the same; this allows Functions to be invoked at multiple
  points where the first M indices represent an M-d array of points to
  evaluate the function, while the last N indices should match the
  Functions domain and codomain dimensions.`

derivativeAtPoint(self, *args)
  `derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain,
  double time = 0.0)
  derivativeAtPoint(self, MDArrayString deriv_spec, MDArray domain, MDArray codomain)
  void stk_classic::percept::Function::derivativeAtPoint(MDArrayString
  &deriv_spec, MDArray &domain, MDArray &codomain, double time=0.0)`

getIntegrationOrder(self)
  `getIntegrationOrder(self) -> unsigned int
  unsigned stk_classic::percept::Function::getIntegrationOrder(void)`

getName(self)
  `getName(self) -> string
  std::string&
  stk_classic::percept::Function::getName()`

setCodomainDimensions(self, *args)
  `setCodomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setCodomainDimensions(const Dimensions
  dims)`

setDomainDimensions(self, *args)
  `setDomainDimensions(self, Dimensions dims)
  void stk_classic::percept::Function::setDomainDimensions(const Dimensions
  dims)`

setIntegrationOrder(self, *args)
  `setIntegrationOrder(self, unsigned int iord)
  void stk_classic::percept::Function::setIntegrationOrder(unsigned iord)`

value(self, *args)
  `value(self, MDArray domain, MDArray MDOutVal, double time_value_optional = 0.0)
  value(self, MDArray domain, MDArray MDOutVal)
  value(self, MDArray domain, double time_value_optional = 0.0) -> MDArray
  value(self, MDArray domain) -> MDArray
  MDArray
  stk_classic::percept::Function::value(MDArray &domain, double
  time_value_optional=0.0)
  this version creates a dummy output and returns it based on the
  codomain-dimensions specified at construction`

Static methods inherited from Function:

setCodomainDimDefault(*args)
  `setCodomainDimDefault(unsigned int codomainDim)`

setIntegrationOrderDefault(*args)
  `setIntegrationOrderDefault(unsigned int integration_order)`

setSpatialDimDefault(*args)
  `setSpatialDimDefault(unsigned int spatialDim)`

Data and other attributes inherited from Function:

Identity = <PerceptMesh.Function; proxy of <Swig Object of type 'stk_classic::percept::Function *' at 0x18870480> >

Methods inherited from GenericFunction:

getCodomainDimensions(self)
  `getCodomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getCodomainDimensions()`

getDomainDimensions(self)
  `getDomainDimensions(self) -> Dimensions
  Dimensions
  stk_classic::percept::GenericFunction::getDomainDimensions()`

getNewCodomain(self)
  `getNewCodomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewCodomain() const`

getNewDomain(self)
  `getNewDomain(self) -> MDArray
  MDArray stk_classic::percept::GenericFunction::getNewDomain()`

isSpatialOperator(self)
  `isSpatialOperator(self) -> bool
  bool
  stk_classic::percept::GenericFunction::isSpatialOperator()`

setIsSpatialOperator(self, *args)
  `setIsSpatialOperator(self, bool so)
  void
  stk_classic::percept::GenericFunction::setIsSpatialOperator(bool so)`

Static methods inherited from GenericFunction:

getNewMDArray(*args)
  `getNewMDArray(Dimensions dims) -> MDArray`

Data descriptors inherited from GenericFunction:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

class SwigPyIterator(__builtin__.object)

``

Methods defined here:

__add__(self, *args)

__eq__(self, *args)

__getattr__ lambda self, name

__iadd__(self, *args)

__init__(self, *args, **kwargs)

__isub__(self, *args)

__iter__(self)

__ne__(self, *args)

__next__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__sub__(self, *args)

advance(self, *args)

copy(self)

decr(self, n=1)

distance(self, *args)

equal(self, *args)

incr(self, n=1)

next(self)

previous(self)

value(self)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_SwigPyIterator>

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class To_Ptr(__builtin__.object)
`` | `Proxy of C++ stk_classic::mesh::To_Ptr class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> To_Ptr`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_To_Ptr>
  `delete_To_Ptr(To_Ptr self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class UniformRefinerPatternBase(__builtin__.object)
`` | `The base class for all refinement patterns ------------------------------------------------------------------------------------------------------------------------ C++ includes: UniformRefinerPattern.hpp`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args, **kwargs)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

connectSides(self, *args)
  `connectSides(self, PerceptMesh eMesh, Entity element, Entity side_elem) -> bool
  bool
  stk_classic::adapt::UniformRefinerPatternBase::connectSides(percept::PerceptMesh
  &eMesh, stk_classic::mesh::Entity *element, stk_classic::mesh::Entity *side_elem)`

createNewElements(self, *args)
  `createNewElements(self, PerceptMesh eMesh, NodeRegistry nodeRegistry, Entity element,
  NewSubEntityNodesType new_sub_entity_nodes,
  vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)>::iterator element_pool,
  FieldBase proc_rank_field = None)
  createNewElements(self, PerceptMesh eMesh, NodeRegistry nodeRegistry, Entity element,
  NewSubEntityNodesType new_sub_entity_nodes,
  vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)>::iterator element_pool)
  virtual
  void
  stk_classic::adapt::UniformRefinerPatternBase::createNewElements(percept::PerceptMesh
  &eMesh, NodeRegistry &nodeRegistry, stk_classic::mesh::Entity &element,
  NewSubEntityNodesType &new_sub_entity_nodes, vector< stk_classic::mesh::Entity
  * >::iterator &element_pool, stk_classic::mesh::FieldBase
  *proc_rank_field=0)=0
  given the node database ( NodeRegistry), and the newly created nodes,
  and an iterator for the elements in the element pool, create all new
  sub-elements of the refined element`

doBreak(self)
  `doBreak(self)
  virtual void stk_classic::adapt::UniformRefinerPatternBase::doBreak()=0`

fillNeededEntities(self, *args)
  `fillNeededEntities(self, std::vector<(NeededEntityType,std::allocator<(NeededEntityType)>)> needed_entities)
  virtual
  void
  stk_classic::adapt::UniformRefinerPatternBase::fillNeededEntities(std::vector<
  NeededEntityType > &needed_entities)=0
  must be provided by derived classes
  ------------------------------------------------------------------------------------------------------------------------
  supplies the ranks of the sub entities needed during refinement (eg.
  m_eMesh.face_rank(), m_eMesh.edge_rank(),..) 10/02/10 and the number
  of nodes needed for each sub entity`

findSideRelations(self, *args)
  `findSideRelations(self, PerceptMesh eMesh, Entity parent, Entity child) -> bool
  bool
  stk_classic::adapt::UniformRefinerPatternBase::findSideRelations(percept::PerceptMesh
  &eMesh, stk_classic::mesh::Entity *parent, stk_classic::mesh::Entity *child)
  given a new element (child) that is a child of an original element
  (parent), look at parent's side to elem relations and from the
  children of the element, choose an element to connect the new side to
  (using connectSides)`

fixSurfaceAndEdgeSetNamesMap(self)
  `fixSurfaceAndEdgeSetNamesMap(self) -> StringStringMap
  virtual StringStringMap
  stk_classic::adapt::UniformRefinerPatternBase::fixSurfaceAndEdgeSetNamesMap()
  for i/o to work properly, supply string replacements such as for
  hex-->tet breaking, you would supply "quad"-->"tri" etc. string
  maps`

getAppendConvertString(self)
  `getAppendConvertString(self) -> string
  const
  std::string&
  stk_classic::adapt::UniformRefinerPatternBase::getAppendConvertString()`

getAppendOriginalString(self)
  `getAppendOriginalString(self) -> string
  const
  std::string&
  stk_classic::adapt::UniformRefinerPatternBase::getAppendOriginalString()`

getCentroid(self, *args)
  `getCentroid(self, double pts, int len, int spatialDim, double x) -> double
  double*
  stk_classic::adapt::UniformRefinerPatternBase::getCentroid(double *pts[], int
  len, int spatialDim, double *x)`

getFromParts(self)
  `getFromParts(self) -> PartVector
  stk_classic::mesh::PartVector&
  stk_classic::adapt::UniformRefinerPatternBase::getFromParts()`

getFromTopoPartName(self)
  `getFromTopoPartName(self) -> string
  virtual
  std::string
  stk_classic::adapt::UniformRefinerPatternBase::getFromTopoPartName()=0
  provided by this class
  ------------------------------------------------------------------------------------------------------------------------`

getFromTopology(self)
  `getFromTopology(self) -> CellTopologyData
  virtual const
  CellTopologyData*
  stk_classic::adapt::UniformRefinerPatternBase::getFromTopology()=0`

getFromTypeKey(self)
  `getFromTypeKey(self) -> unsigned int
  virtual
  unsigned stk_classic::adapt::UniformRefinerPatternBase::getFromTypeKey()=0`

getName(self)
  `getName(self) -> string
  virtual std::string stk_classic::adapt::UniformRefinerPatternBase::getName()`

getNumNewElemPerElem(self)
  `getNumNewElemPerElem(self) -> unsigned int
  virtual
  unsigned
  stk_classic::adapt::UniformRefinerPatternBase::getNumNewElemPerElem()=0
  supply the number of new elements per element during refinement`

getPrimaryEntityRank(self)
  `getPrimaryEntityRank(self) -> EntityRank
  stk_classic::mesh::EntityRank
  stk_classic::adapt::UniformRefinerPatternBase::getPrimaryEntityRank()`

getToParts(self)
  `getToParts(self) -> PartVector
  stk_classic::mesh::PartVector&
  stk_classic::adapt::UniformRefinerPatternBase::getToParts()`

getToTopoPartName(self)
  `getToTopoPartName(self) -> string
  virtual
  std::string
  stk_classic::adapt::UniformRefinerPatternBase::getToTopoPartName()=0`

getToTopology(self)
  `getToTopology(self) -> CellTopologyData
  virtual const
  CellTopologyData*
  stk_classic::adapt::UniformRefinerPatternBase::getToTopology()=0`

interpolateElementFields(self, *args)
  `interpolateElementFields(self, PerceptMesh eMesh, Entity old_owning_elem, Entity newElement)
  void
  stk_classic::adapt::UniformRefinerPatternBase::interpolateElementFields(percept::PerceptMesh
  &eMesh, stk_classic::mesh::Entity &old_owning_elem, stk_classic::mesh::Entity
  &newElement)`

midPoint(self, *args)
  `midPoint(self, double p1, double p2, int spatialDim, double x) -> double
  double* stk_classic::adapt::UniformRefinerPatternBase::midPoint(const double
  *p1, const double *p2, int spatialDim, double *x)`

setNeededParts(self, *args)
  `setNeededParts(self, PerceptMesh eMesh, BlockNamesType block_names_ranks,
  bool sameTopology = True)
  setNeededParts(self, PerceptMesh eMesh, BlockNamesType block_names_ranks)
  virtual void
  stk_classic::adapt::UniformRefinerPatternBase::setNeededParts(percept::PerceptMesh
  &eMesh, BlockNamesType block_names_ranks, bool sameTopology=true)`

setSubPatterns(self, *args)
  `setSubPatterns(self, std::vector<(p.stk_classic::adapt::UniformRefinerPatternBase,std::allocator<(p.stk_classic::adapt::UniformRefinerPatternBase)>)> bp,
  PerceptMesh eMesh)
  virtual void
  stk_classic::adapt::UniformRefinerPatternBase::setSubPatterns(std::vector<
  UniformRefinerPatternBase * > &bp, percept::PerceptMesh &eMesh)
  optionally overridden (must be overridden if sidesets are to work
  properly) to provide info on which sub pattern should be used to
  refine side sets (and edge sets)
  default is only this pattern`

setToOne(self, *args)
  `setToOne(self, std::vector<(NeededEntityType,std::allocator<(NeededEntityType)>)> needed_entities)
  void stk_classic::adapt::UniformRefinerPatternBase::setToOne(std::vector<
  NeededEntityType > &needed_entities)
  utilities --------- sets the needed number of nodes on each sub-entity
  to 1 - this is just a helper - in general, edges and faces have 1 new
  node for linear elements, and multiple new nodes in the case of
  quadratic elements`

set_parent_child_relations(self, *args)
  `set_parent_child_relations(self, PerceptMesh eMesh, Entity old_owning_elem, Entity newElement,
  unsigned int ordinal, unsigned int numChild = None)
  set_parent_child_relations(self, PerceptMesh eMesh, Entity old_owning_elem, Entity newElement,
  unsigned int ordinal)
  void
  stk_classic::adapt::UniformRefinerPatternBase::set_parent_child_relations(percept::PerceptMesh
  &eMesh, stk_classic::mesh::Entity &old_owning_elem, stk_classic::mesh::Entity
  &newElement, unsigned ordinal, unsigned *numChild=0)
  if numChild is passed in as non-null, use that value, else use
  getNumNewElemPerElem() as size of child vector`

Static methods defined here:

createPattern(*args)
  `createPattern(string refine, string enrich, string convert, PerceptMesh eMesh,
  BlockNamesType block_names) -> Teuchos::RCP<(stk_classic::adapt::UniformRefinerPatternBase)>`

getOldElementsPartName()
  `getOldElementsPartName() -> string`

getTopoDim(*args)
  `getTopoDim(shards::CellTopology cell_topo) -> int`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

s_convert_options

s_enrich_options

s_refine_options

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_UniformRefinerPatternBase>
  `delete_UniformRefinerPatternBase(UniformRefinerPatternBase self)
  virtual
  stk_classic::adapt::UniformRefinerPatternBase::~UniformRefinerPatternBase()`

__swig_getmethods__ = {'createPattern': <function <lambda>>, 'getOldElementsPartName': <function <lambda>>, 'getTopoDim': <function <lambda>>, 's_convert_options': <built-in function UniformRefinerPatternBase_s_convert_options_get>, 's_enrich_options': <built-in function UniformRefinerPatternBase_s_enrich_options_get>, 's_refine_options': <built-in function UniformRefinerPatternBase_s_refine_options_get>}

__swig_setmethods__ = {'s_convert_options': <built-in function UniformRefinerPatternBase_s_convert_options_set>, 's_enrich_options': <built-in function UniformRefinerPatternBase_s_enrich_options_set>, 's_refine_options': <built-in function UniformRefinerPatternBase_s_refine_options_set>}

class WedgeFixture(__builtin__.object)
`` | `Proxy of C++ stk_classic::percept::WedgeFixture class`

Methods defined here:

__getattr__ lambda self, name

__init__(self)
  `__init__(self) -> WedgeFixture`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

createBulkAfterMetaCommit(self, *args)
  `createBulkAfterMetaCommit(self, ParallelMachine parallel_machine)
  void
  stk_classic::percept::WedgeFixture::createBulkAfterMetaCommit(stk_classic::ParallelMachine
  parallel_machine)`

createFixedSizeMesh(self, *args)
  `createFixedSizeMesh(self, ParallelMachine parallel_machine, string output_filename)
  void
  stk_classic::percept::WedgeFixture::createFixedSizeMesh(stk_classic::ParallelMachine
  parallel_machine, std::string output_filename)`

createMesh(self, *args)
  `createMesh(self, ParallelMachine parallel_machine, unsigned int n_nodes_x,
  unsigned int n_nodes_y, unsigned int n_nodes_z,
  double xmin, double xmax, double ymin,
  double ymax, double zmin, double zmax, string output_filename) -> BulkData
  mesh::BulkData*
  stk_classic::percept::WedgeFixture::createMesh(stk_classic::ParallelMachine
  parallel_machine, unsigned n_nodes_x, unsigned n_nodes_y, unsigned
  n_nodes_z, double xmin, double xmax, double ymin, double ymax, double
  zmin, double zmax, std::string output_filename)`

getMetaData(self)
  `getMetaData(self) -> FEMMetaData
  mesh::fem::FEMMetaData* stk_classic::percept::WedgeFixture::getMetaData()`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_WedgeFixture>
  `delete_WedgeFixture(WedgeFixture self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class Writer(__builtin__.object)
`` | `Proxy of C++ stk_classic::diag::Writer class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, std::streambuf streambuf, PrintMask print_mask = static_cast< PrintMask >(LOG_MEMBERS),
  Flags flags = static_cast< stk_classic::diag::Writer::Flags >(ENABLED)) -> Writer
  __init__(self, std::streambuf streambuf, PrintMask print_mask = static_cast< PrintMask >(LOG_MEMBERS)) -> Writer
  __init__(self, std::streambuf streambuf) -> Writer`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

decTraceDepth(self)
  `decTraceDepth(self) -> int`

dendl(self)
  `dendl(self) -> Writer`

dflush(self)
  `dflush(self) -> Writer`

getDepth(self)
  `getDepth(self) -> int`

getFlags(self)
  `getFlags(self) -> int`

getPrintMask(self)
  `getPrintMask(self) -> PrintMask`

getStream(self)
  `getStream(self) -> std::ostream`

incTraceDepth(self)
  `incTraceDepth(self) -> int`

isEnabled(self)
  `isEnabled(self) -> bool`

isLoggable(self, *args)
  `isLoggable(self, PrintMask line_mask) -> bool`

isTraceable(self)
  `isTraceable(self) -> bool`

isTracing(self)
  `isTracing(self) -> bool`

m(self, *args)
  `m(self, PrintMask line_mask) -> Writer`

pop(self)
  `pop(self) -> Writer`

push(self)
  `push(self) -> Writer`

resetLineMask(self)
  `resetLineMask(self) -> Writer`

restoreDepth(self, *args)
  `restoreDepth(self, int depth) -> Writer`

setFlags(self, *args)
  `setFlags(self, int flags) -> Writer`

setLineMask(self, *args)
  `setLineMask(self, PrintMask line_mask) -> Writer`

setPrintMask(self, mask=0)
  `setPrintMask(self, PrintMask mask = 0) -> Writer
  setPrintMask(self) -> Writer`

shouldPrint(self, *args)
  `shouldPrint(self) -> bool
  shouldPrint(self, PrintMask line_mask) -> bool`

shouldTrace(self, *args)
  `shouldTrace(self, int line_mask) -> bool`

t(self, line_mask=0)
  `t(self, PrintMask line_mask = 0) -> Writer
  t(self) -> Writer`

w(self, *args)
  `w(self, bool on, PrintMask line_mask) -> Writer`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

DISABLED = 0

ENABLED = 1

__swig_destroy__ = <built-in function delete_Writer>
  `delete_Writer(Writer self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class WriterThrowSafe(__builtin__.object)
`` | `Proxy of C++ stk_classic::diag::WriterThrowSafe class`

Methods defined here:

__getattr__ lambda self, name

__init__(self, *args)
  `__init__(self, Writer writer) -> WriterThrowSafe`

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_WriterThrowSafe>
  `delete_WriterThrowSafe(WriterThrowSafe self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectord(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectord>
  `delete_vectord(vectord self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectorfieldbase(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectorfieldbase>
  `delete_vectorfieldbase(vectorfieldbase self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectori(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectori>
  `delete_vectori(vectori self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectorparts(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectorparts>
  `delete_vectorparts(vectorparts self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectors(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectors>
  `delete_vectors(vectors self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

class vectorvs(__builtin__.object)

``

Methods defined here:

__bool__(self)

__delitem__(self, *args)

__delslice__(self, *args)

__getattr__ lambda self, name

__getitem__(self, *args)

__getslice__(self, *args)

__init__(self, *args)

__iter__(self)

__len__(self)

__nonzero__(self)

__repr__ = _swig_repr(self)

__setattr__ lambda self, name, value

__setitem__(self, *args)

__setslice__(self, *args)

append(self, *args)

assign(self, *args)

back(self)

begin(self)

capacity(self)

clear(self)

empty(self)

end(self)

erase(self, *args)

front(self)

get_allocator(self)

insert(self, *args)

iterator(self)

pop(self)

pop_back(self)

push_back(self, *args)

rbegin(self)

rend(self)

reserve(self, *args)

resize(self, *args)

size(self)

swap(self, *args)

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Data and other attributes defined here:

__swig_destroy__ = <built-in function delete_vectorvs>
  `delete_vectorvs(vectorvs self)`

__swig_getmethods__ = {}

__swig_setmethods__ = {}

Functions

``

BeamFixture_swigregister(...)

BucketLess_swigregister(...)

Bucket_swigregister(...)

BulkData_get(*args)
  `get(Bucket bucket) -> BulkData
  get(Entity entity) -> BulkData
  BulkData_get(Ghosting ghost) -> BulkData`

BulkData_swigregister(...)

ConstantFunctionVec_swigregister(...)

ConstantFunction_swigregister(...)

Dimensions_swigregister(...)

FEMMetaData_get(*args)
  `get(MetaData meta) -> FEMMetaData
  get(Part part) -> FEMMetaData
  get(FieldBase field) -> FEMMetaData
  get(PropertyBase property) -> FEMMetaData
  get(BulkData bulk_data) -> FEMMetaData
  get(Bucket bucket) -> FEMMetaData
  get(Entity entity) -> FEMMetaData
  FEMMetaData_get(Ghosting ghost) -> FEMMetaData`

FEMMetaData_get_meta_data(*args)
  `FEMMetaData_get_meta_data(FEMMetaData fem_meta) -> MetaData`

FEMMetaData_swigregister(...)

FieldBase_swigregister(...)

FieldCreateOrder_swigregister(...)

FieldFunction_swigregister(...)

FieldRepository_swigregister(...)

Function_setCodomainDimDefault(*args)
  `Function_setCodomainDimDefault(unsigned int codomainDim)`

Function_setIntegrationOrderDefault(*args)
  `Function_setIntegrationOrderDefault(unsigned int integration_order)`

Function_setSpatialDimDefault(*args)
  `Function_setSpatialDimDefault(unsigned int spatialDim)`

Function_swigregister(...)

GMeshSpec_swigregister(...)

GenericFunction_getNewMDArray(*args)
  `GenericFunction_getNewMDArray(Dimensions dims) -> MDArray`

GenericFunction_swigregister(...)

Gmesh_STKmesh_Fixture_swigregister(...)

HeterogeneousFixture_swigregister(...)

L1Norm_swigregister(...)

L2Norm_swigregister(...)

LInfNorm_swigregister(...)

MDArrayString_swigregister(...)

MDArray_swigregister(...)

MaxOfNodeValues_swigregister(...)

MeshTransformer_swigregister(...)

Name_swigregister(...)

OpType_swigregister(...)

PartLess_swigregister(...)

PartOrdLess_swigregister(...)

Part_swigregister(...)

PerceptMesh_mesh_difference(*args)
  `mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg, bool _print = True,
  bool print_all_field_diffs = False) -> bool
  mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg, bool _print = True) -> bool
  PerceptMesh_mesh_difference(PerceptMesh mesh1, PerceptMesh mesh2, string msg) -> bool`

PerceptMesh_swigregister(...)

QuadFixture_3_get_entity_rank_names(*args)
  `QuadFixture_3_get_entity_rank_names(unsigned int dim) -> vectors`

QuadFixture_3_swigregister(...)

QuadFixture_4_get_entity_rank_names(*args)
  `QuadFixture_4_get_entity_rank_names(unsigned int dim) -> vectors`

QuadFixture_4_swigregister(...)

RCPComp_swigregister(...)

RCPConstComp_swigregister(...)

RCPFunction_swigregister(...)

Refiner_swigregister(...)

STK_Adapt_Auto_Part_swigregister(...)

Selector_swigregister(...)

SierraPort_swigregister(...)

StringFunction_swigregister(...)

SwigPyIterator_swigregister(...)

To_Ptr_swigregister(...)

UniformRefinerPatternBase_createPattern(*args)
  `UniformRefinerPatternBase_createPattern(string refine, string enrich, string convert, PerceptMesh eMesh,
  BlockNamesType block_names) -> Teuchos::RCP<(stk_classic::adapt::UniformRefinerPatternBase)>`

UniformRefinerPatternBase_getOldElementsPartName()
  `UniformRefinerPatternBase_getOldElementsPartName() -> string`

UniformRefinerPatternBase_getTopoDim(*args)
  `UniformRefinerPatternBase_getTopoDim(shards::CellTopology cell_topo) -> int`

UniformRefinerPatternBase_swigregister(...)

WedgeFixture_swigregister(...)

WriterThrowSafe_swigregister(...)

Writer_swigregister(...)

__add__(*args)
  `__add__(StringFunction lhs, StringFunction rhs) -> StringFunction`

__and__(*args)
  `__and__(Part A, Part B) -> Selector
  __and__(Part A, Selector B) -> Selector
  __and__(Selector A, Part B) -> Selector
  __and__(Selector A, Selector B) -> Selector`

__div__(*args)
  `__div__(StringFunction lhs, StringFunction rhs) -> StringFunction`

__mul__(*args)
  `__mul__(StringFunction lhs, StringFunction rhs) -> StringFunction`

__or__(*args)
  `__or__(Part A, Part B) -> Selector
  __or__(Part A, Selector B) -> Selector
  __or__(Selector A, Part B) -> Selector
  __or__(Selector A, Selector B) -> Selector`

__sub__(*args)
  `__sub__(StringFunction lhs, StringFunction rhs) -> StringFunction
  __sub__(StringFunction lhs) -> StringFunction`

bucket_part_equal(*args)
  `bucket_part_equal(unsigned int lhs, unsigned int rhs) -> bool`

contain(*args)
  `contain(PartVector arg0, Part arg1) -> bool
  contain(PartVector arg0, PartVector arg1) -> bool`

convert_to_internal_name(*args)
  `convert_to_internal_name(string part_name) -> string`

db_api_int_size(*args)
  `db_api_int_size(GroupingEntity entity) -> size_t`

define_io_fields(*args)
  `define_io_fields(GroupingEntity entity, Ioss::Field::RoleType role,
  Part part, EntityRank part_type)`

define_output_db(*args)
  `define_output_db(Region io_region, mesh::BulkData bulk_data, Region input_region = None,
  Selector anded_selector = None,
  bool sort_stk_parts = False)
  define_output_db(Region io_region, mesh::BulkData bulk_data, Region input_region = None,
  Selector anded_selector = None)
  define_output_db(Region io_region, mesh::BulkData bulk_data, Region input_region = None)
  define_output_db(Region io_region, mesh::BulkData bulk_data)`

dendl(*args)
  `dendl(Writer dout) -> Writer`

dflush(*args)
  `dflush(Writer dout) -> Writer`

edge_rank(*args)
  `edge_rank(mesh::MetaData meta) -> mesh::EntityRank`

element_rank(*args)
  `element_rank(mesh::MetaData meta) -> mesh::EntityRank`

entity_rank_names(*args)
  `entity_rank_names(size_t spatial_dimension) -> vectors`

eval_func(*args)
  `eval_func(double x, double y, double z, double t, Function func) -> double
  eval_func(double x, double y, double z, double t, RCPFunction func) -> double`

eval_func2(*args)
  `eval_func2(double x, double y, double t, Function func) -> double
  eval_func2(double x, double y, double t, RCPFunction func) -> double`

eval_print(*args)
  `eval_print(double x, double y, double z, double t, Function func)
  eval_print(double x, double y, double z, double t, RCPFunction func)`

eval_print2(*args)
  `eval_print2(double x, double y, double t, Function func)
  eval_print2(double x, double y, double t, RCPFunction func)`

eval_vec3(*args)
  `eval_vec3(double x, double y, double z, double t, Function func) -> MDArray
  eval_vec3(double x, double y, double z, double t, RCPFunction func) -> MDArray`

eval_vec3_print(*args)
  `eval_vec3_print(double x, double y, double z, double t, Function func)
  eval_vec3_print(double x, double y, double z, double t, RCPFunction func)`

face_rank(*args)
  `face_rank(mesh::MetaData meta) -> mesh::EntityRank`

field_data_from_ioss(*args)
  `field_data_from_ioss(FieldBase field, std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)> entities,
  GroupingEntity io_entity,
  string io_fld_name)`

field_data_to_ioss(*args)
  `field_data_to_ioss(FieldBase field, std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)> entities,
  GroupingEntity io_entity,
  string io_fld_name,
  Ioss::Field::RoleType filter_role)`

find(*args)
  `find(PartVector arg0, string arg1) -> Part`

get_associated_ioss_entity(*args)
  `get_associated_ioss_entity(mesh::Part part) -> GroupingEntity`

get_cell_topology(*args)
  `get_cell_topology(Bucket bucket) -> CellTopology
  get_cell_topology(Entity entity) -> CellTopology`

get_distribution_factor_field(*args)
  `get_distribution_factor_field(mesh::Part p) -> mesh::Field<(double,mesh::ElementNode,void,void,void,void,void,void)>`

get_entity_list(*args)
  `get_entity_list(GroupingEntity io_entity, EntityRank part_type, BulkData bulk,
  std::vector<(p.stk_classic::mesh::Entity,std::allocator<(p.stk_classic::mesh::Entity)>)> entities)`

get_field_role(*args)
  `get_field_role(mesh::FieldBase f) -> Ioss::Field::RoleType`

get_io_field_type(*args)
  `get_io_field_type(FieldBase field, stk_classic::mesh::FieldRestriction res, std::pair<(std::string,Ioss::Field::BasicType)> result)`

has_superset(*args)
  `has_superset(Bucket arg0, Part p) -> bool
  has_superset(Bucket arg0, unsigned int ordinal) -> bool
  has_superset(Bucket arg0, PartVector arg1) -> bool`

include_entity(*args)
  `include_entity(GroupingEntity entity) -> bool`

initialize_spatial_dimension(*args)
  `initialize_spatial_dimension(mesh::fem::FEMMetaData fem_meta, size_t spatial_dimension,
  vectors entity_rank_names)
  initialize_spatial_dimension(mesh::MetaData meta, size_t spatial_dimension, vectors entity_rank_names)`

insert(*args)
  `insert(PartVector arg0, Part arg1) -> bool`

insert_ordinal(*args)
  `insert_ordinal(OrdinalVector v, unsigned int part_ordinal) -> bool`

internal_part_processing(*args)
  `internal_part_processing(GroupingEntity entity, FEMMetaData meta)
  internal_part_processing(EntityBlock entity, FEMMetaData meta)
  internal_part_processing(GroupingEntity entity, MetaData meta)
  internal_part_processing(EntityBlock entity, MetaData meta)`

intersect(*args)
  `intersect(PartVector arg0, PartVector arg1) -> size_t
  intersect(PartVector arg0, PartVector arg1, PartVector arg2) -> size_t
  intersect(Part arg0, Part arg1) -> bool`

invalid_rank(*args)
  `invalid_rank(mesh::EntityRank rank) -> bool`

ioss_add_fields(*args)
  `ioss_add_fields(Part part, EntityRank part_type, GroupingEntity entity,
  Ioss::Field::RoleType filter_role, bool add_all = False)
  ioss_add_fields(Part part, EntityRank part_type, GroupingEntity entity,
  Ioss::Field::RoleType filter_role)`

is_cell_topology_root_part(*args)
  `is_cell_topology_root_part(Part part) -> bool`

is_internal(*args)
  `is_internal(string part_name) -> bool
  is_internal(Part part) -> bool`

is_part_io_part(*args)
  `is_part_io_part(mesh::Part part) -> bool`

is_valid_part_field(*args)
  `is_valid_part_field(FieldBase field, EntityRank part_type, Part part, Part universal,
  Ioss::Field::RoleType filter_role,
  bool add_all = False) -> bool
  is_valid_part_field(FieldBase field, EntityRank part_type, Part part, Part universal,
  Ioss::Field::RoleType filter_role) -> bool`

lower_bound(*args)
  `lower_bound(std::vector<(p.stk_classic::mesh::Bucket,std::allocator<(p.stk_classic::mesh::Bucket)>)> v,
  unsigned int key) -> std::vector<(p.stk_classic::mesh::Bucket,std::allocator<(p.stk_classic::mesh::Bucket)>)>::iterator`

map_topology_cell_to_ioss(*args)
  `map_topology_cell_to_ioss(CellTopologyData cell_top, int spatial_dimension) -> string`

map_topology_ioss_to_cell(*args)
  `map_topology_ioss_to_cell(ElementTopology topology) -> CellTopologyData`

node_rank(*args)
  `node_rank(mesh::MetaData meta) -> mesh::EntityRank`

order(*args)
  `order(PartVector arg0)
  order(OrdinalVector v)`

parallel_machine_barrier(*args)
  `parallel_machine_barrier(ParallelMachine parallel_machine)`

parallel_machine_finalize()
  `parallel_machine_finalize()`

parallel_machine_init(*args)
  `parallel_machine_init(int argc, char argv) -> ParallelMachine`

parallel_machine_null()
  `parallel_machine_null() -> ParallelMachine`

parallel_machine_rank(*args)
  `parallel_machine_rank(ParallelMachine parallel_machine) -> unsigned int`

parallel_machine_size(*args)
  `parallel_machine_size(ParallelMachine parallel_machine) -> unsigned int`

part_primary_entity_rank(*args)
  `part_primary_entity_rank(mesh::Part part) -> mesh::EntityRank`

pop(*args)
  `pop(Writer dout) -> Writer`

push(*args)
  `push(Writer dout) -> Writer`

put_io_part_attribute(*args)
  `put_io_part_attribute(mesh::Part part, GroupingEntity entity = None)
  put_io_part_attribute(mesh::Part part)`

remove(*args)
  `remove(PartVector arg0, Part arg1)`

remove_io_part_attribute(*args)
  `remove_io_part_attribute(mesh::Part part)`

resetlinemask(*args)
  `resetlinemask(Writer dout) -> Writer`

selectField(*args)
  `selectField(FieldBase field) -> Selector`

selectIntersection(*args)
  `selectIntersection(PartVector intersection_part_vector) -> Selector`

selectUnion(*args)
  `selectUnion(PartVector union_part_vector) -> Selector`

set_cell_topology(*args)
  `set_cell_topology(Part part, CellTopology cell_topology)`

set_distribution_factor_field(*args)
  `set_distribution_factor_field(mesh::Part p, mesh::Field<(double,mesh::ElementNode,void,void,void,void,void,void)> df_field)`

set_field_relations(*args)
  `set_field_relations(Entity e_from, Entity e_to, unsigned int ident)`

set_field_role(*args)
  `set_field_role(mesh::FieldBase f, Ioss::Field::RoleType role)`

setlinemask(*args)
  `setlinemask(PrintMask line_mask) -> _setlinemask`

side_rank(*args)
  `side_rank(mesh::MetaData meta) -> mesh::EntityRank`

square(*args)
  `square(double x) -> double`

vectord_swigregister(...)

vectorfieldbase_swigregister(...)

vectori_swigregister(...)

vectorparts_swigregister(...)

vectors_swigregister(...)

vectorvs_swigregister(...)

verifyMesh(*args)
  `verifyMesh(BeamFixture mesh) -> bool
  verifyMesh(HeterogeneousFixture mesh) -> bool`

write_output_db(*args)
  `write_output_db(Region io_region, mesh::BulkData bulk, Selector anded_selector = None)
  write_output_db(Region io_region, mesh::BulkData bulk)`

Data

``

BEAM2_BEAM2_2 = 1
BEAM2_BEAM3_1 = 29
BEAM3_BEAM3_2 = 17
BaseEntityRank = 0
COMPOUND = 1
DEBUG_URP_HPP = 0
EXTRA_PRINT_FF_HELPER = 0
EntityLogCreated = 1
EntityLogDeleted = 3
EntityLogModified = 2
EntityLogNoChange = 0
EntityRankEnd = 6
FAMILY_TREE_CHILD_START_INDEX = 1
FAMILY_TREE_LEVEL_0 = 0
FAMILY_TREE_LEVEL_1 = 1
FAMILY_TREE_PARENT = 0
FORCE_TRACE_PRINT_ONLY = 0
HET_FIX_INCLUDE_EXTRA_ELEM_TYPES = 0
HEX20_HEX20_8 = 22
HEX27_HEX27_8 = 21
HEX8_HEX20_1 = 34
HEX8_HEX27_1 = 33
HEX8_HEX8_8 = 13
HEX8_TET4_24 = 41
HEX8_TET4_6_12 = 42
INTERNAL_PART_POSTFIX = '}'
INTERNAL_PART_PREFIX = '{'
INVALID = 0
InvalidEntityRank = 4294967295
InvalidOrdinal = 4294967295
InvalidPartOrdinal = 4294967295
InvalidRelationIdentifier = 4294967295
LINE2_LINE2_2 = 0
LINE3_LINE3_2 = 16
MaximumFieldDimension = 7
NEW_FIX_ELEMENT_SIDES = 1
PART_ID = 2
PERCEPT_QF_USE_COORD_GATHER_FIELD = 0
PERCEPT_USE_FAMILY_TREE = 1
PERCEPT_USE_PSEUDO_ELEMENTS = 0
PYRAMID13_PYRAMID13_10 = 26
PYRAMID5_PYRAMID13_1 = 37
PYRAMID5_PYRAMID5_10 = 15
QUAD4_QUAD4_4 = 5
QUAD4_QUAD4_4_OLD = 4
QUAD4_QUAD4_4_SIERRA = 6
QUAD4_QUAD8_1 = 28
QUAD4_QUAD9_1 = 27
QUAD4_TRI3_2 = 38
QUAD4_TRI3_4 = 39
QUAD4_TRI3_6 = 40
QUAD8_QUAD8_4 = 20
QUAD9_QUAD9_4 = 19
RCP_UNDEFINED_WEAK_NO_DEALLOC = 0
RCP_UNDEFINED_WITH_DEALLOC = 0
RCP_WEAK_NO_DEALLOC = 0
SHELLLINE2_SHELLLINE2_2 = 2
SHELLLINE3_SHELLLINE3_2 = 3
SHELLQUAD4_SHELLQUAD4_4 = 10
SHELLQUAD4_SHELLQUAD8_1 = 30
SHELLQUAD8_SHELLQUAD8_4 = 11
SHELLTRI3_SHELLTRI3_4 = 8
SHELLTRI6_SHELLTRI6_4 = 9
STK_ADAPT_URP_LOCAL_NODE_COMPS = 0
TET10_TET10_8 = 23
TET4_TET10_1 = 32
TET4_TET4_8 = 12
TRACE_STAGE_PRINT_ON = 0
TRI3_TRI3_4 = 7
TRI3_TRI6_1 = 31
TRI6_TRI6_4 = 18
UNIFORM_REF_REMOVE_OLD_BOOST_SET = 0
UNIFORM_REF_REMOVE_OLD_STD_SET = 1
UNIFORM_REF_REMOVE_OLD_STD_VECTOR = 0
WEDGE15_WEDGE15_8 = 24
WEDGE18_WEDGE18_8 = 25
WEDGE6_WEDGE15_1 = 35
WEDGE6_WEDGE18_1 = 36
WEDGE6_WEDGE6_8 = 14
cvar = <Swig global variables>