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>