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>