Panzer Version of the Day
Loading...
Searching...
No Matches
Panzer_STK_Interface.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// Panzer: A partial differential equation assembly
4// engine for strongly coupled complex multiphysics systems
5//
6// Copyright 2011 NTESS and the Panzer contributors.
7// SPDX-License-Identifier: BSD-3-Clause
8// *****************************************************************************
9// @HEADER
10
11#ifndef __Panzer_STK_Interface_hpp__
12#define __Panzer_STK_Interface_hpp__
13
14#include <Teuchos_RCP.hpp>
15#include <Teuchos_DefaultMpiComm.hpp>
16
17#include <stk_mesh/base/Types.hpp>
18#include <stk_mesh/base/MetaData.hpp>
19#include <stk_mesh/base/BulkData.hpp>
20#include <stk_mesh/base/Field.hpp>
21#include <stk_mesh/base/FieldBase.hpp>
22
23#include "Kokkos_Core.hpp"
24
25#include <Shards_CellTopology.hpp>
26#include <Shards_CellTopologyData.h>
27
28#include <PanzerAdaptersSTK_config.hpp>
29#include <Kokkos_ViewFactory.hpp>
30
31#include <unordered_map>
32
33#ifdef PANZER_HAVE_IOSS
34#include <stk_io/StkMeshIoBroker.hpp>
35#endif
36
37#ifdef PANZER_HAVE_PERCEPT
38namespace percept {
39 class PerceptMesh;
40 class URP_Heterogeneous_3D;
41}
42#endif
43
44namespace panzer_stk {
45
46class PeriodicBC_MatcherBase;
47
51class ElementDescriptor {
52public:
54 ElementDescriptor(stk::mesh::EntityId gid,const std::vector<stk::mesh::EntityId> & nodes);
55 virtual ~ElementDescriptor();
56
58 stk::mesh::EntityId getGID() const { return gid_; }
60 const std::vector<stk::mesh::EntityId> & getNodes() const { return nodes_; }
61protected:
62 stk::mesh::EntityId gid_;
63 std::vector<stk::mesh::EntityId> nodes_;
64
65 ElementDescriptor();
66};
67
70Teuchos::RCP<ElementDescriptor>
71buildElementDescriptor(stk::mesh::EntityId elmtId,std::vector<stk::mesh::EntityId> & nodes);
72
73class STK_Interface {
74public:
75 typedef double ProcIdData; // ECC: Not sure why?
76 typedef stk::mesh::Field<double> SolutionFieldType;
77 typedef stk::mesh::Field<double> VectorFieldType;
78 typedef stk::mesh::Field<ProcIdData> ProcIdFieldType;
79
80 // some simple exception classes
81 struct ElementBlockException : public std::logic_error
82 { ElementBlockException(const std::string & what) : std::logic_error(what) {} };
83
84 struct SidesetException : public std::logic_error
85 { SidesetException(const std::string & what) : std::logic_error(what) {} };
86
87 struct EdgeBlockException : public std::logic_error
88 { EdgeBlockException(const std::string & what) : std::logic_error(what) {} };
89
90 struct FaceBlockException : public std::logic_error
91 { FaceBlockException(const std::string & what) : std::logic_error(what) {} };
92
94 STK_Interface();
95
98 STK_Interface(unsigned dim);
99
101 STK_Interface(Teuchos::RCP<stk::mesh::MetaData> metaData);
102
103 // functions called before initialize
105
108 void addElementBlock(const std::string & name,const CellTopologyData * ctData);
109
112// void addEdgeBlock(const std::string & name,const CellTopologyData * ctData);
113 void addEdgeBlock(const std::string & elemBlockName,
114 const std::string & edgeBlockName,
115 const stk::topology & topology);
116 void addEdgeBlock(const std::string & elemBlockName,
117 const std::string & edgeBlockName,
118 const CellTopologyData * ctData);
119
122 void addFaceBlock(const std::string & elemBlockName,
123 const std::string & faceBlockName,
124 const stk::topology & topology);
125 void addFaceBlock(const std::string & elemBlockName,
126 const std::string & faceBlockName,
127 const CellTopologyData * ctData);
128
131 void addSideset(const std::string & name,const CellTopologyData * ctData);
132
135 void addNodeset(const std::string & name);
136
139 void addSolutionField(const std::string & fieldName,const std::string & blockId);
140
143 void addCellField(const std::string & fieldName,const std::string & blockId);
144
147 void addEdgeField(const std::string & fieldName,const std::string & blockId);
148
151 void addFaceField(const std::string & fieldName,const std::string & blockId);
152
161 void addMeshCoordFields(const std::string & blockId,
162 const std::vector<std::string> & coordField,
163 const std::string & dispPrefix);
164
169 void addInformationRecords(const std::vector<std::string> & info_records);
170
172
184 void initialize(stk::ParallelMachine parallelMach,bool setupIO=true,
185 const bool buildRefinementSupport = false);
186
192 void instantiateBulkData(stk::ParallelMachine parallelMach);
193
194 // functions to manage and manipulate bulk data
196
199 void beginModification();
200
213 void endModification(const bool find_and_set_shared_nodes_in_stk=true);
214
220 void addNode(stk::mesh::EntityId gid, const std::vector<double> & coord);
221
223 void addElement(const Teuchos::RCP<ElementDescriptor> & ed,stk::mesh::Part * block);
224
226 void addEdges();
227
229 void addFaces();
230
233 void addEntityToSideset(stk::mesh::Entity entity,stk::mesh::Part * sideset);
234
237 void addEntityToNodeset(stk::mesh::Entity entity,stk::mesh::Part * nodeset);
238
241 void addEntityToEdgeBlock(stk::mesh::Entity entity,stk::mesh::Part * edgeblock);
244 void addEntitiesToEdgeBlock(std::vector<stk::mesh::Entity> entities,stk::mesh::Part * edgeblock);
245
248 void addEntityToFaceBlock(stk::mesh::Entity entity,stk::mesh::Part * faceblock);
251 void addEntitiesToFaceBlock(std::vector<stk::mesh::Entity> entities,stk::mesh::Part * faceblock);
252
253 // Methods to interrogate the mesh topology and structure
255
258 const VectorFieldType & getCoordinatesField() const
259 { return *coordinatesField_; }
260
263 const VectorFieldType & getEdgesField() const
264 { return *edgesField_; }
265
267 const VectorFieldType & getFacesField() const
268 { return *facesField_; }
269
272 const double * getNodeCoordinates(stk::mesh::EntityId nodeId) const;
273
276 const double * getNodeCoordinates(stk::mesh::Entity node) const;
277
284 void getSubcellIndices(unsigned entityRank,stk::mesh::EntityId elementId,
285 std::vector<stk::mesh::EntityId> & subcellIds) const;
286
289 void getMyElements(std::vector<stk::mesh::Entity> & elements) const;
290
293 void getMyElements(const std::string & blockID,std::vector<stk::mesh::Entity> & elements) const;
294
298 void getNeighborElements(std::vector<stk::mesh::Entity> & elements) const;
299
302 void getNeighborElements(const std::string & blockID,std::vector<stk::mesh::Entity> & elements) const;
303
306 void getMyEdges(std::vector<stk::mesh::Entity> & edges) const;
307
315 void getMyEdges(const std::string & edgeBlockName,std::vector<stk::mesh::Entity> & edges) const;
316
325 void getMyEdges(const std::string & edgeBlockName,const std::string & blockName,std::vector<stk::mesh::Entity> & edges) const;
326
334 void getAllEdges(const std::string & edgeBlockName,std::vector<stk::mesh::Entity> & edges) const;
335
344 void getAllEdges(const std::string & edgeBlockName,const std::string & blockName,std::vector<stk::mesh::Entity> & edges) const;
345
348 void getMyFaces(std::vector<stk::mesh::Entity> & faces) const;
349
357 void getMyFaces(const std::string & faceBlockName,std::vector<stk::mesh::Entity> & faces) const;
358
367 void getMyFaces(const std::string & faceBlockName,const std::string & blockName,std::vector<stk::mesh::Entity> & faces) const;
368
376 void getAllFaces(const std::string & faceBlockName,std::vector<stk::mesh::Entity> & faces) const;
377
386 void getAllFaces(const std::string & faceBlockName,const std::string & blockName,std::vector<stk::mesh::Entity> & faces) const;
387
395 void getMySides(const std::string & sideName,std::vector<stk::mesh::Entity> & sides) const;
396
405 void getMySides(const std::string & sideName,const std::string & blockName,std::vector<stk::mesh::Entity> & sides) const;
406
414 void getAllSides(const std::string & sideName,std::vector<stk::mesh::Entity> & sides) const;
415
424 void getAllSides(const std::string & sideName,const std::string & blockName,std::vector<stk::mesh::Entity> & sides) const;
425
435 void getMyNodes(const std::string & sideName,const std::string & blockName,std::vector<stk::mesh::Entity> & nodes) const;
436
445 stk::mesh::Entity findConnectivityById(stk::mesh::Entity src, stk::mesh::EntityRank tgt_rank, unsigned rel_id) const;
446
447 // Utility functions
449
458 void
459 writeToExodus(const std::string& filename,
460 const bool append = false);
461
479 void
480 setupExodusFile(const std::string& filename,
481 const bool append = false,
482 const bool append_after_restart_time = false,
483 const double restart_time = 0.0);
484
503 void
504 setupExodusFile(const std::string& filename,
505 const std::vector<Ioss::Property>& ioss_properties,
506 const bool append = false,
507 const bool append_after_restart_time = false,
508 const double restart_time = 0.0);
509
522 void
523 writeToExodus(
524 double timestep);
525
545 void
546 addGlobalToExodus(
547 const std::string& key,
548 const int& value);
549
569 void
570 addGlobalToExodus(
571 const std::string& key,
572 const double& value);
573
593 void
594 addGlobalToExodus(
595 const std::string& key,
596 const std::vector<int>& value);
597
617 void
618 addGlobalToExodus(
619 const std::string& key,
620 const std::vector<double>& value);
621
622 // Accessor functions
624
626 Teuchos::RCP<const Teuchos::Comm<int> > getComm() const;
627
629 Teuchos::RCP<stk::mesh::BulkData> getBulkData() const { return bulkData_; }
631 Teuchos::RCP<stk::mesh::MetaData> getMetaData() const { return metaData_; }
632
633#ifdef PANZER_HAVE_PERCEPT
635 Teuchos::RCP<percept::PerceptMesh> getRefinedMesh() const
636 { TEUCHOS_ASSERT(Teuchos::nonnull(refinedMesh_)); return refinedMesh_; }
637#endif
638
640 bool isWritable() const;
641
643 bool isModifiable() const
644 { if(bulkData_==Teuchos::null) return false;
645 return bulkData_->in_modifiable_state(); }
646
648 unsigned getDimension() const
649 { return dimension_; }
650
652 std::size_t getNumElementBlocks() const
653 { return elementBlocks_.size(); }
654
662 void getElementBlockNames(std::vector<std::string> & names) const;
663
671 void getSidesetNames(std::vector<std::string> & name) const;
672
680 void getNodesetNames(std::vector<std::string> & name) const;
681
689 void getEdgeBlockNames(std::vector<std::string> & names) const;
690
698 void getFaceBlockNames(std::vector<std::string> & names) const;
699
701 stk::mesh::Part * getOwnedPart() const
702 { return &getMetaData()->locally_owned_part(); } // I don't like the pointer access here, but it will do for now!
703
705 stk::mesh::Part * getElementBlockPart(const std::string & name) const
706 {
707 std::map<std::string, stk::mesh::Part*>::const_iterator itr = elementBlocks_.find(name); // Element blocks
708 if(itr==elementBlocks_.end()) return 0;
709 return itr->second;
710 }
711
713 stk::mesh::Part * getEdgeBlock(const std::string & name) const
714 {
715 std::map<std::string, stk::mesh::Part*>::const_iterator itr = edgeBlocks_.find(name); // edge blocks
716 if(itr==edgeBlocks_.end()) return 0;
717 return itr->second;
718 }
719
721 stk::mesh::Part * getFaceBlock(const std::string & name) const
722 {
723 std::map<std::string, stk::mesh::Part*>::const_iterator itr = faceBlocks_.find(name); // face blocks
724 if(itr==faceBlocks_.end()) return 0;
725 return itr->second;
726 }
727
729 std::size_t getNumSidesets() const
730 { return sidesets_.size(); }
731
732 stk::mesh::Part * getSideset(const std::string & name) const
733 {
734 auto itr = sidesets_.find(name);
735 return (itr != sidesets_.end()) ? itr->second : nullptr;
736 }
737
739 std::size_t getNumNodesets() const
740 { return nodesets_.size(); }
741
742 stk::mesh::Part * getNodeset(const std::string & name) const
743 {
744 auto itr = nodesets_.find(name);
745 return (itr != nodesets_.end()) ? itr->second : nullptr;
746 }
747
749 std::size_t getEntityCounts(unsigned entityRank) const;
750
752 stk::mesh::EntityId getMaxEntityId(unsigned entityRank) const;
753
754 // Utilities
756
758 void getElementsSharingNode(stk::mesh::EntityId nodeId,std::vector<stk::mesh::Entity> & elements) const;
759
761 void getNodeIdsForElement(stk::mesh::Entity element,std::vector<stk::mesh::EntityId> & nodeIds) const;
762
769 void getOwnedElementsSharingNode(stk::mesh::Entity node,std::vector<stk::mesh::Entity> & elements,
770 std::vector<int> & relIds) const;
771
779 void getOwnedElementsSharingNode(stk::mesh::EntityId nodeId,std::vector<stk::mesh::Entity> & elements,
780 std::vector<int> & relIds, unsigned int matchType) const;
781
782
784 void getElementsSharingNodes(const std::vector<stk::mesh::EntityId> nodeId,std::vector<stk::mesh::Entity> & elements) const;
785
787 void buildSubcells();
788
791 std::size_t elementLocalId(stk::mesh::Entity elmt) const;
792
795 std::size_t elementLocalId(stk::mesh::EntityId gid) const;
796
799 inline stk::mesh::EntityId elementGlobalId(std::size_t lid) const
800 { return bulkData_->identifier((*orderedElementVector_)[lid]); }
801
804 inline stk::mesh::EntityId elementGlobalId(stk::mesh::Entity elmt) const
805 { return bulkData_->identifier(elmt); }
806
809 bool isEdgeLocal(stk::mesh::Entity edge) const;
810
813 bool isEdgeLocal(stk::mesh::EntityId gid) const;
814
817 std::size_t edgeLocalId(stk::mesh::Entity elmt) const;
818
821 std::size_t edgeLocalId(stk::mesh::EntityId gid) const;
822
825 inline stk::mesh::EntityId edgeGlobalId(std::size_t lid) const
826 { return bulkData_->identifier((*orderedEdgeVector_)[lid]); }
827
830 inline stk::mesh::EntityId edgeGlobalId(stk::mesh::Entity edge) const
831 { return bulkData_->identifier(edge); }
832
835 bool isFaceLocal(stk::mesh::Entity face) const;
836
839 bool isFaceLocal(stk::mesh::EntityId gid) const;
840
843 std::size_t faceLocalId(stk::mesh::Entity elmt) const;
844
847 std::size_t faceLocalId(stk::mesh::EntityId gid) const;
848
851 inline stk::mesh::EntityId faceGlobalId(std::size_t lid) const
852 { return bulkData_->identifier((*orderedFaceVector_)[lid]); }
853
856 inline stk::mesh::EntityId faceGlobalId(stk::mesh::Entity face) const
857 { return bulkData_->identifier(face); }
858
861 inline unsigned entityOwnerRank(stk::mesh::Entity entity) const
862 { return bulkData_->parallel_owner_rank(entity); }
863
866 inline bool isValid(stk::mesh::Entity entity) const
867 { return bulkData_->is_valid(entity); }
868
871 std::string containingBlockId(stk::mesh::Entity elmt) const;
872
877 stk::mesh::Field<double> * getSolutionField(const std::string & fieldName,
878 const std::string & blockId) const;
879
884 stk::mesh::Field<double> * getCellField(const std::string & fieldName,
885 const std::string & blockId) const;
886
891 stk::mesh::Field<double> * getEdgeField(const std::string & fieldName,
892 const std::string & blockId) const;
893
898 stk::mesh::Field<double> * getFaceField(const std::string & fieldName,
899 const std::string & blockId) const;
900
902 ProcIdFieldType * getProcessorIdField() { return processorIdField_; }
903
905 bool isInitialized() const { return initialized_; }
906
910 Teuchos::RCP<const std::vector<stk::mesh::Entity> > getElementsOrderedByLID() const;
911
926 template <typename ArrayT>
927 void setSolutionFieldData(const std::string & fieldName,const std::string & blockId,
928 const std::vector<std::size_t> & localElementIds,const ArrayT & solutionValues,double scaleValue=1.0);
929
944 template <typename ArrayT>
945 void getSolutionFieldData(const std::string & fieldName,const std::string & blockId,
946 const std::vector<std::size_t> & localElementIds,ArrayT & solutionValues) const;
947
962 template <typename ArrayT>
963 void setCellFieldData(const std::string & fieldName,const std::string & blockId,
964 const std::vector<std::size_t> & localElementIds,const ArrayT & solutionValues,double scaleValue=1.0);
965
969 Teuchos::RCP<const std::vector<stk::mesh::Entity> > getEdgesOrderedByLID() const;
970
974 Teuchos::RCP<const std::vector<stk::mesh::Entity> > getFacesOrderedByLID() const;
975
990 template <typename ArrayT>
991 void setEdgeFieldData(const std::string & fieldName,const std::string & blockId,
992 const std::vector<std::size_t> & localEdgeIds,const ArrayT & edgeValues,double scaleValue=1.0);
993
1008 template <typename ArrayT>
1009 void setFaceFieldData(const std::string & fieldName,const std::string & blockId,
1010 const std::vector<std::size_t> & localFaceIds,const ArrayT & faceValues,double scaleValue=1.0);
1011
1013
1022 template <typename ArrayT>
1023 void getElementVertices(const std::vector<std::size_t> & localIds, ArrayT & vertices) const;
1024
1033 template <typename ArrayT>
1034 void getElementVertices(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const;
1035
1045 template <typename ArrayT>
1046 void getElementVertices(const std::vector<std::size_t> & localIds,const std::string & eBlock, ArrayT & vertices) const;
1047
1057 template <typename ArrayT>
1058 void getElementVertices(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const;
1059
1068 template <typename ArrayT>
1069 void getElementVerticesNoResize(const std::vector<std::size_t> & localIds, ArrayT & vertices) const;
1070
1079 template <typename ArrayT>
1080 void getElementVerticesNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const;
1081
1091 template <typename ArrayT>
1092 void getElementVerticesNoResize(const std::vector<std::size_t> & localIds,const std::string & eBlock, ArrayT & vertices) const;
1093
1103 template <typename ArrayT>
1104 void getElementVerticesNoResize(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const;
1105
1107
1117 template <typename ArrayT>
1118 void getElementNodes(const std::vector<std::size_t> & localIds, ArrayT & nodes) const;
1119
1128 template <typename ArrayT>
1129 void getElementNodes(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const;
1130
1140 template <typename ArrayT>
1141 void getElementNodes(const std::vector<std::size_t> & localIds,const std::string & eBlock, ArrayT & nodes) const;
1142
1152 template <typename ArrayT>
1153 void getElementNodes(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const;
1154
1163 template <typename ArrayT>
1164 void getElementNodesNoResize(const std::vector<std::size_t> & localIds, ArrayT & nodes) const;
1165
1174 template <typename ArrayT>
1175 void getElementNodesNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const;
1176
1186 template <typename ArrayT>
1187 void getElementNodesNoResize(const std::vector<std::size_t> & localIds,const std::string & eBlock, ArrayT & nodes) const;
1188
1198 template <typename ArrayT>
1199 void getElementNodesNoResize(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const;
1200
1201 // const stk::mesh::FEMInterface & getFEMInterface() const
1202 // { return *femPtr_; }
1203
1205 stk::mesh::EntityRank getElementRank() const { return stk::topology::ELEMENT_RANK; }
1207 stk::mesh::EntityRank getSideRank() const { return metaData_->side_rank(); }
1209 stk::mesh::EntityRank getFaceRank() const { return stk::topology::FACE_RANK; }
1211 stk::mesh::EntityRank getEdgeRank() const { return stk::topology::EDGE_RANK; }
1213 stk::mesh::EntityRank getNodeRank() const { return stk::topology::NODE_RANK; }
1214
1217 void initializeFromMetaData();
1218
1221 void buildLocalElementIDs();
1222
1225 void buildLocalEdgeIDs();
1226
1229 void buildLocalFaceIDs();
1230
1233 const std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > &
1234 getPeriodicBCVector() const
1235 { return periodicBCs_; }
1236
1239 std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > &
1242
1245 const bool & useBoundingBoxSearch() const
1246 { return useBBoxSearch_; }
1247
1249 void setBoundingBoxSearchFlag(const bool & searchFlag)
1250 { useBBoxSearch_ = searchFlag; return; }
1251
1257 void addPeriodicBC(const Teuchos::RCP<const PeriodicBC_MatcherBase> & bc)
1258 { periodicBCs_.push_back(bc); }
1259
1265 void addPeriodicBCs(const std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > & bc_vec)
1266 { periodicBCs_.insert(periodicBCs_.end(),bc_vec.begin(),bc_vec.end()); }
1267
1270 std::pair<Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >, Teuchos::RCP<std::vector<unsigned int> > >
1271 getPeriodicNodePairing() const;
1272
1275 bool validBlockId(const std::string & blockId) const;
1276
1279 void print(std::ostream & os) const;
1280
1283 void printMetaData(std::ostream & os) const;
1284
1287 Teuchos::RCP<const shards::CellTopology> getCellTopology(const std::string & eBlock) const;
1288
1293 double getCurrentStateTime() const { return currentStateTime_; }
1294
1300 double getInitialStateTime() const { return initialStateTime_; }
1301
1306 void setInitialStateTime(double value) { initialStateTime_ = value; }
1307
1310 void rebalance(const Teuchos::ParameterList & params);
1311
1315 void setBlockWeight(const std::string & blockId,double weight)
1316 { blockWeights_[blockId] = weight; }
1317
1324 void setUseFieldCoordinates(bool useFieldCoordinates)
1325 { useFieldCoordinates_ = useFieldCoordinates; }
1326
1328 bool getUseFieldCoordinates() const
1329 { return useFieldCoordinates_; }
1330
1332 void setUseLowerCaseForIO(bool useLowerCase)
1333 { useLowerCase_ = useLowerCase; }
1334
1336 bool getUseLowerCaseForIO() const
1337 { return useLowerCase_; }
1338
1340
1351 template <typename ArrayT>
1352 void getElementVertices_FromField(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const;
1353
1355 template <typename ArrayT>
1356 void getElementVertices_FromFieldNoResize(const std::vector<stk::mesh::Entity> & elements,
1357 const std::string & eBlock, ArrayT & vertices) const;
1358
1368 template <typename ArrayT>
1369 void getElementVertices_FromCoords(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const;
1370
1372 template <typename ArrayT>
1373 void getElementVertices_FromCoordsNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const;
1374
1376
1387 template <typename ArrayT>
1388 void getElementNodes_FromField(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const;
1389
1391 template <typename ArrayT>
1392 void getElementNodes_FromFieldNoResize(const std::vector<stk::mesh::Entity> & elements,
1393 const std::string & eBlock, ArrayT & nodes) const;
1394
1404 template <typename ArrayT>
1405 void getElementNodes_FromCoords(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const;
1406
1408 template <typename ArrayT>
1409 void getElementNodes_FromCoordsNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const;
1410
1416 void refineMesh(const int numberOfLevels, const bool deleteParentElements);
1417
1418public: // static operations
1419 static const std::string coordsString;
1420 static const std::string nodesString;
1421 static const std::string edgesString;
1422 static const std::string edgeBlockString;
1423 static const std::string faceBlockString;
1424 static const std::string facesString;
1425
1426protected:
1427
1430 void buildEntityCounts();
1431
1434 void buildMaxEntityIds();
1435
1442 void initializeFieldsInSTK(const std::map<std::pair<std::string,std::string>,SolutionFieldType*> & nameToField,
1443 bool setupIO);
1444
1449 Teuchos::RCP<Teuchos::MpiComm<int> > getSafeCommunicator(stk::ParallelMachine parallelMach) const;
1450
1456 void applyElementLoadBalanceWeights();
1457
1465 bool isMeshCoordField(const std::string & eBlock,const std::string & fieldName,int & axis) const;
1466
1482 template <typename ArrayT>
1483 void setDispFieldData(const std::string & fieldName,const std::string & blockId,int axis,
1484 const std::vector<std::size_t> & localElementIds,const ArrayT & solutionValues);
1485
1486 std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > periodicBCs_;
1487 bool useBBoxSearch_ = true;
1488
1489 Teuchos::RCP<stk::mesh::MetaData> metaData_;
1490 Teuchos::RCP<stk::mesh::BulkData> bulkData_;
1491#ifdef PANZER_HAVE_PERCEPT
1492 Teuchos::RCP<percept::PerceptMesh> refinedMesh_;
1493 Teuchos::RCP<percept::URP_Heterogeneous_3D> breakPattern_;
1494#endif
1495
1496 std::map<std::string, stk::mesh::Part*> elementBlocks_; // Element blocks
1497 std::map<std::string, stk::mesh::Part*> sidesets_; // Side sets
1498 std::map<std::string, stk::mesh::Part*> nodesets_; // Node sets
1499 std::map<std::string, stk::mesh::Part*> edgeBlocks_; // Edge blocks
1500 std::map<std::string, stk::mesh::Part*> faceBlocks_; // Face blocks
1501
1502 std::map<std::string, Teuchos::RCP<shards::CellTopology> > elementBlockCT_;
1503
1504 // for storing/accessing nodes
1505 stk::mesh::Part * nodesPart_;
1506 std::vector<stk::mesh::Part*> nodesPartVec_;
1507 stk::mesh::Part * edgesPart_;
1508 std::vector<stk::mesh::Part*> edgesPartVec_;
1509 stk::mesh::Part * facesPart_;
1510 std::vector<stk::mesh::Part*> facesPartVec_;
1511
1512 VectorFieldType * coordinatesField_;
1513 VectorFieldType * edgesField_;
1514 VectorFieldType * facesField_;
1515 ProcIdFieldType * processorIdField_;
1516 SolutionFieldType * loadBalField_;
1517
1518 // maps field names to solution field stk mesh handles
1519 std::map<std::pair<std::string,std::string>,SolutionFieldType*> fieldNameToSolution_;
1520 std::map<std::pair<std::string,std::string>,SolutionFieldType*> fieldNameToCellField_;
1521 std::map<std::pair<std::string,std::string>,SolutionFieldType*> fieldNameToEdgeField_;
1522 std::map<std::pair<std::string,std::string>,SolutionFieldType*> fieldNameToFaceField_;
1523
1524 // use a set to maintain a list of unique information records
1525 std::set<std::string> informationRecords_;
1526
1527 unsigned dimension_;
1528
1529 bool initialized_;
1530
1531 // how many elements, faces, edges, and nodes are there globally
1532 std::vector<std::size_t> entityCounts_;
1533
1534 // what is maximum entity ID
1535 std::vector<stk::mesh::EntityId> maxEntityId_;
1536
1537 unsigned procRank_;
1538 std::size_t currentLocalId_;
1539
1540 Teuchos::RCP<Teuchos::MpiComm<int> > mpiComm_;
1541
1542 double initialStateTime_; // the time stamp at the time this object was constructed (default 0.0)
1543 double currentStateTime_; // the time stamp set by the user when writeToExodus is called (default 0.0)
1544
1545#ifdef PANZER_HAVE_IOSS
1546 // I/O support
1547 Teuchos::RCP<stk::io::StkMeshIoBroker> meshData_;
1548 int meshIndex_;
1549
1554 enum class GlobalVariable
1555 {
1556 ADD,
1557 WRITE
1558 }; // end of enum class GlobalVariable
1559
1576 void
1577 globalToExodus(
1578 const GlobalVariable& flag);
1579
1583 Teuchos::ParameterList globalData_;
1584#endif
1585
1586 // uses lazy evaluation
1587 mutable Teuchos::RCP<std::vector<stk::mesh::Entity> > orderedElementVector_;
1588
1589 // uses lazy evaluation
1590 mutable Teuchos::RCP<std::vector<stk::mesh::Entity> > orderedEdgeVector_;
1591
1592 // uses lazy evaluation
1593 mutable Teuchos::RCP<std::vector<stk::mesh::Entity> > orderedFaceVector_;
1594
1595 // for element block weights
1596 std::map<std::string,double> blockWeights_;
1597
1598 std::unordered_map<stk::mesh::EntityId,std::size_t> localIDHash_;
1599 std::unordered_map<stk::mesh::EntityId,std::size_t> localEdgeIDHash_;
1600 std::unordered_map<stk::mesh::EntityId,std::size_t> localFaceIDHash_;
1601
1602 // Store mesh displacement fields by element block. This map
1603 // goes like this meshCoordFields_[eBlock][axis_index] => coordinate FieldName
1604 // goes like this meshDispFields_[eBlock][axis_index] => displacement FieldName
1605 std::map<std::string,std::vector<std::string> > meshCoordFields_; // coordinate fields written by user
1606 std::map<std::string,std::vector<std::string> > meshDispFields_; // displacement fields, output to exodus
1607
1608 bool useFieldCoordinates_;
1609
1610 bool useLowerCase_;
1611
1612 // Object describing how to sort a vector of elements using
1613 // local ID as the key, very short lived object
1614 class LocalIdCompare {
1615 public:
1616 LocalIdCompare(const STK_Interface * mesh) : mesh_(mesh) {}
1617
1618 // Compares two stk mesh entities based on local ID
1619 bool operator() (stk::mesh::Entity a,stk::mesh::Entity b)
1620 { return mesh_->elementLocalId(a) < mesh_->elementLocalId(b);}
1621
1622 private:
1623 const STK_Interface * mesh_;
1624 };
1625};
1626
1627template <typename ArrayT>
1628void STK_Interface::setSolutionFieldData(const std::string & fieldName,const std::string & blockId,
1629 const std::vector<std::size_t> & localElementIds,const ArrayT & solutionValues,double scaleValue)
1630{
1631 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1632 auto solutionValues_h = Kokkos::create_mirror_view(solutionValues);
1633 Kokkos::deep_copy(solutionValues_h, solutionValues);
1634
1635 int field_axis = -1;
1636 if(isMeshCoordField(blockId,fieldName,field_axis)) {
1637 setDispFieldData(fieldName,blockId,field_axis,localElementIds,solutionValues_h);
1638 return;
1639 }
1640
1641 SolutionFieldType * field = this->getSolutionField(fieldName,blockId);
1642
1643 for(std::size_t cell=0;cell<localElementIds.size();cell++) {
1644 std::size_t localId = localElementIds[cell];
1645 stk::mesh::Entity element = elements[localId];
1646
1647 // loop over nodes set solution values
1648 const size_t num_nodes = bulkData_->num_nodes(element);
1649 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
1650 for(std::size_t i=0; i<num_nodes; ++i) {
1651 stk::mesh::Entity node = nodes[i];
1652
1653 double * solnData = stk::mesh::field_data(*field,node);
1654 // TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1655 solnData[0] = scaleValue*solutionValues_h(cell,i);
1656 }
1657 }
1658}
1659
1660template <typename ArrayT>
1661void STK_Interface::setDispFieldData(const std::string & fieldName,const std::string & blockId,int axis,
1662 const std::vector<std::size_t> & localElementIds,const ArrayT & dispValues)
1663{
1664 TEUCHOS_ASSERT(axis>=0); // sanity check
1665
1666 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1667
1668 SolutionFieldType * field = this->getSolutionField(fieldName,blockId);
1669 const VectorFieldType & coord_field = this->getCoordinatesField();
1670
1671 for(std::size_t cell=0;cell<localElementIds.size();cell++) {
1672 std::size_t localId = localElementIds[cell];
1673 stk::mesh::Entity element = elements[localId];
1674
1675 // loop over nodes set solution values
1676 const size_t num_nodes = bulkData_->num_nodes(element);
1677 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
1678 for(std::size_t i=0; i<num_nodes; ++i) {
1679 stk::mesh::Entity node = nodes[i];
1680
1681 double * solnData = stk::mesh::field_data(*field,node);
1682 double * coordData = stk::mesh::field_data(coord_field,node);
1683 // TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1684 solnData[0] = dispValues(cell,i)-coordData[axis];
1685 }
1686 }
1687}
1688
1689template <typename ArrayT>
1690void STK_Interface::getSolutionFieldData(const std::string & fieldName,const std::string & blockId,
1691 const std::vector<std::size_t> & localElementIds,ArrayT & solutionValues) const
1692{
1693 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1694
1695 solutionValues = Kokkos::createDynRankView(solutionValues,
1696 "solutionValues",
1697 localElementIds.size(),
1698 bulkData_->num_nodes(elements[localElementIds[0]]));
1699
1700 SolutionFieldType * field = this->getSolutionField(fieldName,blockId);
1701
1702 for(std::size_t cell=0;cell<localElementIds.size();cell++) {
1703 std::size_t localId = localElementIds[cell];
1704 stk::mesh::Entity element = elements[localId];
1705
1706 // loop over nodes set solution values
1707 const size_t num_nodes = bulkData_->num_nodes(element);
1708 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
1709 for(std::size_t i=0; i<num_nodes; ++i) {
1710 stk::mesh::Entity node = nodes[i];
1711
1712 double * solnData = stk::mesh::field_data(*field,node);
1713 // TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1714 solutionValues(cell,i) = solnData[0];
1715 }
1716 }
1717}
1718
1719template <typename ArrayT>
1720void STK_Interface::setCellFieldData(const std::string & fieldName,const std::string & blockId,
1721 const std::vector<std::size_t> & localElementIds,const ArrayT & solutionValues,double scaleValue)
1722{
1723 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1724
1725 SolutionFieldType * field = this->getCellField(fieldName,blockId);
1726
1727 auto solutionValues_h = Kokkos::create_mirror_view(solutionValues);
1728 Kokkos::deep_copy(solutionValues_h, solutionValues);
1729
1730 for(std::size_t cell=0;cell<localElementIds.size();cell++) {
1731 std::size_t localId = localElementIds[cell];
1732 stk::mesh::Entity element = elements[localId];
1733
1734 double * solnData = stk::mesh::field_data(*field,element);
1735 TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1736 solnData[0] = scaleValue*solutionValues_h.access(cell,0);
1737 }
1738}
1739
1740template <typename ArrayT>
1741void STK_Interface::setEdgeFieldData(const std::string & fieldName,const std::string & blockId,
1742 const std::vector<std::size_t> & localEdgeIds,const ArrayT & edgeValues,double scaleValue)
1743{
1744 const std::vector<stk::mesh::Entity> & edges = *(this->getEdgesOrderedByLID());
1745
1746 SolutionFieldType * field = this->getEdgeField(fieldName,blockId);
1747
1748 auto edgeValues_h = Kokkos::create_mirror_view(edgeValues);
1749 Kokkos::deep_copy(edgeValues_h, edgeValues);
1750
1751 for(std::size_t idx=0;idx<localEdgeIds.size();idx++) {
1752 std::size_t localId = localEdgeIds[idx];
1753 stk::mesh::Entity edge = edges[localId];
1754
1755 double * solnData = stk::mesh::field_data(*field,edge);
1756 TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1757 solnData[0] = scaleValue*edgeValues_h.access(idx,0);
1758 }
1759}
1760
1761template <typename ArrayT>
1762void STK_Interface::setFaceFieldData(const std::string & fieldName,const std::string & blockId,
1763 const std::vector<std::size_t> & localFaceIds,const ArrayT & faceValues,double scaleValue)
1764{
1765 const std::vector<stk::mesh::Entity> & faces = *(this->getFacesOrderedByLID());
1766
1767 SolutionFieldType * field = this->getFaceField(fieldName,blockId);
1768
1769 auto faceValues_h = Kokkos::create_mirror_view(faceValues);
1770 Kokkos::deep_copy(faceValues_h, faceValues);
1771
1772 for(std::size_t idx=0;idx<localFaceIds.size();idx++) {
1773 std::size_t localId = localFaceIds[idx];
1774 stk::mesh::Entity face = faces[localId];
1775
1776 double * solnData = stk::mesh::field_data(*field,face);
1777 TEUCHOS_ASSERT(solnData!=0); // only needed if blockId is not specified
1778 solnData[0] = scaleValue*faceValues_h.access(idx,0);
1779 }
1780}
1781
1783
1784template <typename ArrayT>
1785void STK_Interface::getElementVertices(const std::vector<std::size_t> & localElementIds, ArrayT & vertices) const
1786{
1787 if(!useFieldCoordinates_) {
1788 //
1789 // gather from the intrinsic mesh coordinates (non-lagrangian)
1790 //
1791
1792 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1793
1794 // convert to a vector of entity objects
1795 std::vector<stk::mesh::Entity> selected_elements;
1796 for(std::size_t cell=0;cell<localElementIds.size();cell++)
1797 selected_elements.push_back(elements[localElementIds[cell]]);
1798
1799 getElementVertices_FromCoords(selected_elements,vertices);
1800 }
1801 else {
1802 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
1803 "STK_Interface::getElementVertices: Cannot call this method when field coordinates are used "
1804 "without specifying an element block.");
1805 }
1806}
1807
1808template <typename ArrayT>
1809void STK_Interface::getElementVertices(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const
1810{
1811 if(!useFieldCoordinates_) {
1812 getElementVertices_FromCoords(elements,vertices);
1813 }
1814 else {
1815 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
1816 "STK_Interface::getElementVertices: Cannot call this method when field coordinates are used "
1817 "without specifying an element block.");
1818 }
1819}
1820
1821template <typename ArrayT>
1822void STK_Interface::getElementVertices(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const
1823{
1824 if(!useFieldCoordinates_) {
1825 getElementVertices_FromCoords(elements,vertices);
1826 }
1827 else {
1828 getElementVertices_FromField(elements,eBlock,vertices);
1829 }
1830}
1831
1832template <typename ArrayT>
1833void STK_Interface::getElementVertices(const std::vector<std::size_t> & localElementIds,const std::string & eBlock, ArrayT & vertices) const
1834{
1835 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1836
1837 // convert to a vector of entity objects
1838 std::vector<stk::mesh::Entity> selected_elements;
1839 for(std::size_t cell=0;cell<localElementIds.size();cell++)
1840 selected_elements.push_back(elements[localElementIds[cell]]);
1841
1842 if(!useFieldCoordinates_) {
1843 getElementVertices_FromCoords(selected_elements,vertices);
1844 }
1845 else {
1846 getElementVertices_FromField(selected_elements,eBlock,vertices);
1847 }
1848}
1849
1850template <typename ArrayT>
1851void STK_Interface::getElementVerticesNoResize(const std::vector<std::size_t> & localElementIds, ArrayT & vertices) const
1852{
1853 if(!useFieldCoordinates_) {
1854 //
1855 // gather from the intrinsic mesh coordinates (non-lagrangian)
1856 //
1857
1858 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1859
1860 // convert to a vector of entity objects
1861 std::vector<stk::mesh::Entity> selected_elements;
1862 for(std::size_t cell=0;cell<localElementIds.size();cell++)
1863 selected_elements.push_back(elements[localElementIds[cell]]);
1864
1865 getElementVertices_FromCoordsNoResize(selected_elements,vertices);
1866 }
1867 else {
1868 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
1869 "STK_Interface::getElementVerticesNoResize: Cannot call this method when field coordinates are used "
1870 "without specifying an element block.");
1871 }
1872}
1873
1874template <typename ArrayT>
1875void STK_Interface::getElementVerticesNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const
1876{
1877 if(!useFieldCoordinates_) {
1878 getElementVertices_FromCoordsNoResize(elements,vertices);
1879 }
1880 else {
1881 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
1882 "STK_Interface::getElementVerticesNoResize: Cannot call this method when field coordinates are used "
1883 "without specifying an element block.");
1884 }
1885}
1886
1887template <typename ArrayT>
1888void STK_Interface::getElementVerticesNoResize(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const
1889{
1890 if(!useFieldCoordinates_) {
1891 getElementVertices_FromCoordsNoResize(elements,vertices);
1892 }
1893 else {
1894 getElementVertices_FromFieldNoResize(elements,eBlock,vertices);
1895 }
1896}
1897
1898template <typename ArrayT>
1899void STK_Interface::getElementVerticesNoResize(const std::vector<std::size_t> & localElementIds,const std::string & eBlock, ArrayT & vertices) const
1900{
1901 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
1902
1903 // convert to a vector of entity objects
1904 std::vector<stk::mesh::Entity> selected_elements;
1905 for(std::size_t cell=0;cell<localElementIds.size();cell++)
1906 selected_elements.push_back(elements[localElementIds[cell]]);
1907
1908 if(!useFieldCoordinates_) {
1909 getElementVertices_FromCoordsNoResize(selected_elements,vertices);
1910 }
1911 else {
1912 getElementVertices_FromFieldNoResize(selected_elements,eBlock,vertices);
1913 }
1914}
1915
1916template <typename ArrayT>
1917void STK_Interface::getElementVertices_FromCoords(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const
1918{
1919 // nothing to do! silently return
1920 if(elements.size() == 0) {
1921 vertices = Kokkos::createDynRankView(vertices, "vertices", 0, 0, 0);
1922 return;
1923 }
1924
1925 //
1926 // gather from the intrinsic mesh coordinates (non-lagrangian)
1927 //
1928
1929 // get *master* cell toplogy...(belongs to first element)
1930 const auto masterVertexCount
1931 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->vertex_count;
1932
1933 // allocate space
1934 vertices = Kokkos::createDynRankView(vertices, "vertices", elements.size(), masterVertexCount,getDimension());
1935 auto vertices_h = Kokkos::create_mirror_view(vertices);
1936 Kokkos::deep_copy(vertices_h, vertices);
1937
1938 // loop over each requested element
1939 const auto dim = getDimension();
1940 for(std::size_t cell = 0; cell < elements.size(); cell++) {
1941 const auto element = elements[cell];
1942 TEUCHOS_ASSERT(element != 0);
1943
1944 const auto vertexCount
1945 = stk::mesh::get_cell_topology(bulkData_->bucket(element).topology()).getCellTopologyData()->vertex_count;
1946 TEUCHOS_TEST_FOR_EXCEPTION(vertexCount != masterVertexCount, std::runtime_error,
1947 "In call to STK_Interface::getElementVertices all elements "
1948 "must have the same vertex count!");
1949
1950 // loop over all element nodes
1951 const size_t num_nodes = bulkData_->num_nodes(element);
1952 auto const* nodes = bulkData_->begin_nodes(element);
1953 TEUCHOS_TEST_FOR_EXCEPTION(num_nodes!=masterVertexCount,std::runtime_error,
1954 "In call to STK_Interface::getElementVertices cardinality of "
1955 "element node relations must be the vertex count!");
1956 for(std::size_t node = 0; node < num_nodes; ++node) {
1957 const double * coord = getNodeCoordinates(nodes[node]);
1958
1959 // set each dimension of the coordinate
1960 for(unsigned d=0;d<dim;d++)
1961 vertices_h(cell,node,d) = coord[d];
1962 }
1963 }
1964 Kokkos::deep_copy(vertices, vertices_h);
1965}
1966
1967template <typename ArrayT>
1968void STK_Interface::getElementVertices_FromCoordsNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & vertices) const
1969{
1970 // nothing to do! silently return
1971 if(elements.size()==0) {
1972 return;
1973 }
1974
1975 //
1976 // gather from the intrinsic mesh coordinates (non-lagrangian)
1977 //
1978
1979 // get *master* cell toplogy...(belongs to first element)
1980 unsigned masterVertexCount
1981 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->vertex_count;
1982
1983 // loop over each requested element
1984 unsigned dim = getDimension();
1985 auto vertices_h = Kokkos::create_mirror_view(vertices);
1986 for(std::size_t cell=0;cell<elements.size();cell++) {
1987 stk::mesh::Entity element = elements[cell];
1988 TEUCHOS_ASSERT(element!=0);
1989
1990 unsigned vertexCount
1991 = stk::mesh::get_cell_topology(bulkData_->bucket(element).topology()).getCellTopologyData()->vertex_count;
1992 TEUCHOS_TEST_FOR_EXCEPTION(vertexCount!=masterVertexCount,std::runtime_error,
1993 "In call to STK_Interface::getElementVertices all elements "
1994 "must have the same vertex count!");
1995
1996 // loop over all element nodes
1997 const size_t num_nodes = bulkData_->num_nodes(element);
1998 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
1999 TEUCHOS_TEST_FOR_EXCEPTION(num_nodes!=masterVertexCount,std::runtime_error,
2000 "In call to STK_Interface::getElementVertices cardinality of "
2001 "element node relations must be the vertex count!");
2002 for(std::size_t node=0; node<num_nodes; ++node) {
2003 const double * coord = getNodeCoordinates(nodes[node]);
2004
2005 // set each dimension of the coordinate
2006 for(unsigned d=0;d<dim;d++)
2007 vertices_h(cell,node,d) = coord[d];
2008 }
2009 }
2010 Kokkos::deep_copy(vertices, vertices_h);
2011}
2012
2013template <typename ArrayT>
2014void STK_Interface::getElementVertices_FromField(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & vertices) const
2015{
2016 TEUCHOS_ASSERT(useFieldCoordinates_);
2017
2018 // nothing to do! silently return
2019 if(elements.size()==0) {
2020 vertices = Kokkos::createDynRankView(vertices,"vertices",0,0,0);
2021 return;
2022 }
2023
2024 // get *master* cell toplogy...(belongs to first element)
2025 unsigned masterVertexCount
2026 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->vertex_count;
2027
2028 // allocate space
2029 vertices = Kokkos::createDynRankView(vertices,"vertices",elements.size(),masterVertexCount,getDimension());
2030 auto vertices_h = Kokkos::create_mirror_view(vertices);
2031 std::map<std::string,std::vector<std::string> >::const_iterator itr = meshCoordFields_.find(eBlock);
2032 if(itr==meshCoordFields_.end()) {
2033 // no coordinate field set for this element block
2034 TEUCHOS_ASSERT(false);
2035 }
2036
2037 const std::vector<std::string> & coordField = itr->second;
2038 std::vector<SolutionFieldType*> fields(getDimension());
2039 for(std::size_t d=0;d<fields.size();d++) {
2040 fields[d] = this->getSolutionField(coordField[d],eBlock);
2041 }
2042
2043 for(std::size_t cell=0;cell<elements.size();cell++) {
2044 stk::mesh::Entity element = elements[cell];
2045
2046 // loop over nodes set solution values
2047 const size_t num_nodes = bulkData_->num_nodes(element);
2048 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
2049 for(std::size_t i=0; i<num_nodes; ++i) {
2050 stk::mesh::Entity node = nodes[i];
2051
2052 const double * coord = getNodeCoordinates(node);
2053
2054 for(unsigned d=0;d<getDimension();d++) {
2055 double * solnData = stk::mesh::field_data(*fields[d],node);
2056
2057 // recall mesh field coordinates are stored as displacements
2058 // from the mesh coordinates, make sure to add them together
2059 vertices_h(cell,i,d) = solnData[0]+coord[d];
2060 }
2061 }
2062 }
2063 Kokkos::deep_copy(vertices, vertices_h);
2064}
2065
2066template <typename ArrayT>
2067void STK_Interface::getElementVertices_FromFieldNoResize(const std::vector<stk::mesh::Entity> & elements,
2068 const std::string & eBlock, ArrayT & vertices) const
2069{
2070 TEUCHOS_ASSERT(useFieldCoordinates_);
2071
2072 // nothing to do! silently return
2073 if(elements.size()==0) {
2074 return;
2075 }
2076
2077 std::map<std::string,std::vector<std::string> >::const_iterator itr = meshCoordFields_.find(eBlock);
2078 if(itr==meshCoordFields_.end()) {
2079 // no coordinate field set for this element block
2080 TEUCHOS_ASSERT(false);
2081 }
2082
2083 const std::vector<std::string> & coordField = itr->second;
2084 std::vector<SolutionFieldType*> fields(getDimension());
2085 for(std::size_t d=0;d<fields.size();d++) {
2086 fields[d] = this->getSolutionField(coordField[d],eBlock);
2087 }
2088
2089 for(std::size_t cell=0;cell<elements.size();cell++) {
2090 stk::mesh::Entity element = elements[cell];
2091
2092 // loop over nodes set solution values
2093 const size_t num_nodes = bulkData_->num_nodes(element);
2094 stk::mesh::Entity const* nodes = bulkData_->begin_nodes(element);
2095 for(std::size_t i=0; i<num_nodes; ++i) {
2096 stk::mesh::Entity node = nodes[i];
2097
2098 const double * coord = getNodeCoordinates(node);
2099
2100 for(unsigned d=0;d<getDimension();d++) {
2101 double * solnData = stk::mesh::field_data(*fields[d],node);
2102
2103 // recall mesh field coordinates are stored as displacements
2104 // from the mesh coordinates, make sure to add them together
2105 vertices(cell,i,d) = solnData[0]+coord[d];
2106 }
2107 }
2108 }
2109}
2110
2112
2113template <typename ArrayT>
2114void STK_Interface::getElementNodes(const std::vector<std::size_t> & localElementIds, ArrayT & nodes) const
2115{
2116 if(!useFieldCoordinates_) {
2117 //
2118 // gather from the intrinsic mesh coordinates (non-lagrangian)
2119 //
2120
2121 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
2122
2123 // convert to a vector of entity objects
2124 std::vector<stk::mesh::Entity> selected_elements;
2125 for(std::size_t cell=0;cell<localElementIds.size();cell++)
2126 selected_elements.push_back(elements[localElementIds[cell]]);
2127
2128 getElementNodes_FromCoords(selected_elements,nodes);
2129 }
2130 else {
2131 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
2132 "STK_Interface::getElementNodes: Cannot call this method when field coordinates are used "
2133 "without specifying an element block.");
2134 }
2135}
2136
2137template <typename ArrayT>
2138void STK_Interface::getElementNodes(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const
2139{
2140 if(!useFieldCoordinates_) {
2141 getElementNodes_FromCoords(elements,nodes);
2142 }
2143 else {
2144 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
2145 "STK_Interface::getElementNodes: Cannot call this method when field coordinates are used "
2146 "without specifying an element block.");
2147 }
2148}
2149
2150template <typename ArrayT>
2151void STK_Interface::getElementNodes(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const
2152{
2153 if(!useFieldCoordinates_) {
2154 getElementNodes_FromCoords(elements,nodes);
2155 }
2156 else {
2157 getElementNodes_FromField(elements,eBlock,nodes);
2158 }
2159}
2160
2161template <typename ArrayT>
2162void STK_Interface::getElementNodes(const std::vector<std::size_t> & localElementIds,const std::string & eBlock, ArrayT & nodes) const
2163{
2164 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
2165
2166 // convert to a vector of entity objects
2167 std::vector<stk::mesh::Entity> selected_elements;
2168 for(std::size_t cell=0;cell<localElementIds.size();cell++)
2169 selected_elements.push_back(elements[localElementIds[cell]]);
2170
2171 if(!useFieldCoordinates_) {
2172 getElementNodes_FromCoords(selected_elements,nodes);
2173 }
2174 else {
2175 getElementNodes_FromField(selected_elements,eBlock,nodes);
2176 }
2177}
2178
2179template <typename ArrayT>
2180void STK_Interface::getElementNodesNoResize(const std::vector<std::size_t> & localElementIds, ArrayT & nodes) const
2181{
2182 if(!useFieldCoordinates_) {
2183 //
2184 // gather from the intrinsic mesh coordinates (non-lagrangian)
2185 //
2186
2187 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
2188
2189 // convert to a vector of entity objects
2190 std::vector<stk::mesh::Entity> selected_elements;
2191 for(std::size_t cell=0;cell<localElementIds.size();cell++)
2192 selected_elements.push_back(elements[localElementIds[cell]]);
2193
2194 getElementNodes_FromCoordsNoResize(selected_elements,nodes);
2195 }
2196 else {
2197 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
2198 "STK_Interface::getElementNodesNoResize: Cannot call this method when field coordinates are used "
2199 "without specifying an element block.");
2200 }
2201}
2202
2203template <typename ArrayT>
2204void STK_Interface::getElementNodesNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const
2205{
2206 if(!useFieldCoordinates_) {
2207 getElementNodes_FromCoordsNoResize(elements,nodes);
2208 }
2209 else {
2210 TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,
2211 "STK_Interface::getElementNodesNoResize: Cannot call this method when field coordinates are used "
2212 "without specifying an element block.");
2213 }
2214}
2215
2216template <typename ArrayT>
2217void STK_Interface::getElementNodesNoResize(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const
2218{
2219 if(!useFieldCoordinates_) {
2220 getElementNodes_FromCoordsNoResize(elements,nodes);
2221 }
2222 else {
2223 getElementNodes_FromFieldNoResize(elements,eBlock,nodes);
2224 }
2225}
2226
2227template <typename ArrayT>
2228void STK_Interface::getElementNodesNoResize(const std::vector<std::size_t> & localElementIds,const std::string & eBlock, ArrayT & nodes) const
2229{
2230 const std::vector<stk::mesh::Entity> & elements = *(this->getElementsOrderedByLID());
2231
2232 // convert to a vector of entity objects
2233 std::vector<stk::mesh::Entity> selected_elements;
2234 for(std::size_t cell=0;cell<localElementIds.size();cell++)
2235 selected_elements.push_back(elements[localElementIds[cell]]);
2236
2237 if(!useFieldCoordinates_) {
2238 getElementNodes_FromCoordsNoResize(selected_elements,nodes);
2239 }
2240 else {
2241 getElementNodes_FromFieldNoResize(selected_elements,eBlock,nodes);
2242 }
2243}
2244
2245template <typename ArrayT>
2246void STK_Interface::getElementNodes_FromCoords(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const
2247{
2248 // nothing to do! silently return
2249 if(elements.size() == 0) {
2250 nodes = Kokkos::createDynRankView(nodes, "nodes", 0, 0, 0);
2251 return;
2252 }
2253
2254 //
2255 // gather from the intrinsic mesh coordinates (non-lagrangian)
2256 //
2257
2258 // get *master* cell toplogy...(belongs to first element)
2259 const auto masterNodeCount
2260 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->node_count;
2261
2262 // allocate space
2263 nodes = Kokkos::createDynRankView(nodes, "nodes", elements.size(), masterNodeCount,getDimension());
2264 auto nodes_h = Kokkos::create_mirror_view(nodes);
2265 Kokkos::deep_copy(nodes_h, nodes);
2266
2267 // loop over each requested element
2268 const auto dim = getDimension();
2269 for(std::size_t cell = 0; cell < elements.size(); cell++) {
2270 const auto element = elements[cell];
2271 TEUCHOS_ASSERT(element != 0);
2272
2273 const auto nodeCount
2274 = stk::mesh::get_cell_topology(bulkData_->bucket(element).topology()).getCellTopologyData()->node_count;
2275 TEUCHOS_TEST_FOR_EXCEPTION(nodeCount != masterNodeCount, std::runtime_error,
2276 "In call to STK_Interface::getElementNodes all elements "
2277 "must have the same node count!");
2278
2279 // loop over all element nodes
2280 const size_t num_nodes = bulkData_->num_nodes(element);
2281 auto const* elem_nodes = bulkData_->begin_nodes(element);
2282 TEUCHOS_TEST_FOR_EXCEPTION(num_nodes!=masterNodeCount,std::runtime_error,
2283 "In call to STK_Interface::getElementNodes cardinality of "
2284 "element node relations must be the node count!");
2285 for(std::size_t node = 0; node < num_nodes; ++node) {
2286 const double * coord = getNodeCoordinates(elem_nodes[node]);
2287
2288 // set each dimension of the coordinate
2289 for(unsigned d=0;d<dim;d++)
2290 nodes_h(cell,node,d) = coord[d];
2291 }
2292 }
2293 Kokkos::deep_copy(nodes, nodes_h);
2294}
2295
2296template <typename ArrayT>
2297void STK_Interface::getElementNodes_FromCoordsNoResize(const std::vector<stk::mesh::Entity> & elements, ArrayT & nodes) const
2298{
2299 // nothing to do! silently return
2300 if(elements.size()==0) {
2301 return;
2302 }
2303
2304 //
2305 // gather from the intrinsic mesh coordinates (non-lagrangian)
2306 //
2307
2308 // get *master* cell toplogy...(belongs to first element)
2309 unsigned masterNodeCount
2310 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->node_count;
2311
2312 // loop over each requested element
2313 unsigned dim = getDimension();
2314 auto nodes_h = Kokkos::create_mirror_view(nodes);
2315 for(std::size_t cell=0;cell<elements.size();cell++) {
2316 stk::mesh::Entity element = elements[cell];
2317 TEUCHOS_ASSERT(element!=0);
2318
2319 unsigned nodeCount
2320 = stk::mesh::get_cell_topology(bulkData_->bucket(element).topology()).getCellTopologyData()->node_count;
2321 TEUCHOS_TEST_FOR_EXCEPTION(nodeCount!=masterNodeCount,std::runtime_error,
2322 "In call to STK_Interface::getElementNodes all elements "
2323 "must have the same node count!");
2324
2325 // loop over all element nodes
2326 const size_t num_nodes = bulkData_->num_nodes(element);
2327 stk::mesh::Entity const* elem_nodes = bulkData_->begin_nodes(element);
2328 TEUCHOS_TEST_FOR_EXCEPTION(num_nodes!=masterNodeCount,std::runtime_error,
2329 "In call to STK_Interface::getElementNodes cardinality of "
2330 "element node relations must be the node count!");
2331 for(std::size_t node=0; node<num_nodes; ++node) {
2332 const double * coord = getNodeCoordinates(elem_nodes[node]);
2333
2334 // set each dimension of the coordinate
2335 for(unsigned d=0;d<dim;d++)
2336 nodes_h(cell,node,d) = coord[d];
2337 }
2338 }
2339 Kokkos::deep_copy(nodes, nodes_h);
2340}
2341
2342template <typename ArrayT>
2343void STK_Interface::getElementNodes_FromField(const std::vector<stk::mesh::Entity> & elements,const std::string & eBlock, ArrayT & nodes) const
2344{
2345 TEUCHOS_ASSERT(useFieldCoordinates_);
2346
2347 // nothing to do! silently return
2348 if(elements.size()==0) {
2349 nodes = Kokkos::createDynRankView(nodes,"nodes",0,0,0);
2350 return;
2351 }
2352
2353 // get *master* cell toplogy...(belongs to first element)
2354 unsigned masterNodeCount
2355 = stk::mesh::get_cell_topology(bulkData_->bucket(elements[0]).topology()).getCellTopologyData()->node_count;
2356
2357 // allocate space
2358 nodes = Kokkos::createDynRankView(nodes,"nodes",elements.size(),masterNodeCount,getDimension());
2359 auto nodes_h = Kokkos::create_mirror_view(nodes);
2360 std::map<std::string,std::vector<std::string> >::const_iterator itr = meshCoordFields_.find(eBlock);
2361 if(itr==meshCoordFields_.end()) {
2362 // no coordinate field set for this element block
2363 TEUCHOS_ASSERT(false);
2364 }
2365
2366 const std::vector<std::string> & coordField = itr->second;
2367 std::vector<SolutionFieldType*> fields(getDimension());
2368 for(std::size_t d=0;d<fields.size();d++) {
2369 fields[d] = this->getSolutionField(coordField[d],eBlock);
2370 }
2371
2372 // loop over elements
2373 for(std::size_t cell=0;cell<elements.size();cell++) {
2374 stk::mesh::Entity element = elements[cell];
2375
2376 // loop over nodes set solution values
2377 const size_t num_nodes = bulkData_->num_nodes(element);
2378 stk::mesh::Entity const* elem_nodes = bulkData_->begin_nodes(element);
2379 for(std::size_t i=0; i<num_nodes; ++i) {
2380 stk::mesh::Entity node = elem_nodes[i];
2381
2382 const double * coord = getNodeCoordinates(node);
2383
2384 for(unsigned d=0;d<getDimension();d++) {
2385 double * solnData = stk::mesh::field_data(*fields[d],node);
2386
2387 // recall mesh field coordinates are stored as displacements
2388 // from the mesh coordinates, make sure to add them together
2389 nodes_h(cell,i,d) = solnData[0]+coord[d];
2390 }
2391 }
2392 }
2393 Kokkos::deep_copy(nodes, nodes_h);
2394}
2395
2396template <typename ArrayT>
2397void STK_Interface::getElementNodes_FromFieldNoResize(const std::vector<stk::mesh::Entity> & elements,
2398 const std::string & eBlock, ArrayT & nodes) const
2399{
2400 TEUCHOS_ASSERT(useFieldCoordinates_);
2401
2402 // nothing to do! silently return
2403 if(elements.size()==0) {
2404 return;
2405 }
2406
2407 std::map<std::string,std::vector<std::string> >::const_iterator itr = meshCoordFields_.find(eBlock);
2408 if(itr==meshCoordFields_.end()) {
2409 // no coordinate field set for this element block
2410 TEUCHOS_ASSERT(false);
2411 }
2412
2413 const std::vector<std::string> & coordField = itr->second;
2414 std::vector<SolutionFieldType*> fields(getDimension());
2415 for(std::size_t d=0;d<fields.size();d++) {
2416 fields[d] = this->getSolutionField(coordField[d],eBlock);
2417 }
2418
2419 // loop over elements
2420 for(std::size_t cell=0;cell<elements.size();cell++) {
2421 stk::mesh::Entity element = elements[cell];
2422
2423 // loop over nodes set solution values
2424 const size_t num_nodes = bulkData_->num_nodes(element);
2425 stk::mesh::Entity const* elem_nodes = bulkData_->begin_nodes(element);
2426 for(std::size_t i=0; i<num_nodes; ++i) {
2427 stk::mesh::Entity node = elem_nodes[i];
2428
2429 const double * coord = getNodeCoordinates(node);
2430
2431 for(unsigned d=0;d<getDimension();d++) {
2432 double * solnData = stk::mesh::field_data(*fields[d],node);
2433
2434 // recall mesh field coordinates are stored as displacements
2435 // from the mesh coordinates, make sure to add them together
2436 nodes(cell,i,d) = solnData[0]+coord[d];
2437 }
2438 }
2439 }
2440}
2441
2442}
2443
2444#endif
field
PHX::MDField< ScalarT, panzer::Cell, panzer::BASIS > field
A field to which we'll contribute, or in which we'll store, the result of computing this integral.
Definition Panzer_Integrator_CurlBasisDotVector_impl.hpp:559
panzer_stk::ElementDescriptor
Definition Panzer_STK_Interface.hpp:51
panzer_stk::ElementDescriptor::gid_
stk::mesh::EntityId gid_
Definition Panzer_STK_Interface.hpp:62
panzer_stk::ElementDescriptor::~ElementDescriptor
virtual ~ElementDescriptor()
Definition Panzer_STK_Interface.cpp:60
panzer_stk::ElementDescriptor::ElementDescriptor
ElementDescriptor()
Definition Panzer_STK_Interface.cpp:57
panzer_stk::ElementDescriptor::getNodes
const std::vector< stk::mesh::EntityId > & getNodes() const
Returns the global IDs of the element's nodes.
Definition Panzer_STK_Interface.hpp:60
panzer_stk::ElementDescriptor::nodes_
std::vector< stk::mesh::EntityId > nodes_
Definition Panzer_STK_Interface.hpp:63
panzer_stk::ElementDescriptor::getGID
stk::mesh::EntityId getGID() const
Returns the element's global ID.
Definition Panzer_STK_Interface.hpp:58
panzer_stk::STK_Interface::LocalIdCompare
Definition Panzer_STK_Interface.hpp:1614
panzer_stk::STK_Interface::LocalIdCompare::mesh_
const STK_Interface * mesh_
Definition Panzer_STK_Interface.hpp:1623
panzer_stk::STK_Interface::LocalIdCompare::operator()
bool operator()(stk::mesh::Entity a, stk::mesh::Entity b)
Definition Panzer_STK_Interface.hpp:1619
panzer_stk::STK_Interface::LocalIdCompare::LocalIdCompare
LocalIdCompare(const STK_Interface *mesh)
Definition Panzer_STK_Interface.hpp:1616
panzer_stk::STK_Interface
Definition Panzer_STK_Interface.hpp:73
panzer_stk::STK_Interface::rebalance
void rebalance(const Teuchos::ParameterList &params)
Definition Panzer_STK_Interface.cpp:1989
panzer_stk::STK_Interface::buildLocalElementIDs
void buildLocalElementIDs()
Definition Panzer_STK_Interface.cpp:1699
panzer_stk::STK_Interface::beginModification
void beginModification()
Definition Panzer_STK_Interface.cpp:401
panzer_stk::STK_Interface::getEdgesField
const VectorFieldType & getEdgesField() const
Definition Panzer_STK_Interface.hpp:263
panzer_stk::STK_Interface::addEdges
void addEdges()
Builds edge entities for the mesh from its existing elements.
Definition Panzer_STK_Interface.cpp:523
panzer_stk::STK_Interface::findConnectivityById
stk::mesh::Entity findConnectivityById(stk::mesh::Entity src, stk::mesh::EntityRank tgt_rank, unsigned rel_id) const
Definition Panzer_STK_Interface.cpp:581
panzer_stk::STK_Interface::applyElementLoadBalanceWeights
void applyElementLoadBalanceWeights()
Definition Panzer_STK_Interface.cpp:1742
panzer_stk::STK_Interface::metaData_
Teuchos::RCP< stk::mesh::MetaData > metaData_
Definition Panzer_STK_Interface.hpp:1489
panzer_stk::STK_Interface::facesField_
VectorFieldType * facesField_
Definition Panzer_STK_Interface.hpp:1514
panzer_stk::STK_Interface::orderedFaceVector_
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedFaceVector_
Definition Panzer_STK_Interface.hpp:1593
panzer_stk::STK_Interface::getPeriodicNodePairing
std::pair< Teuchos::RCP< std::vector< std::pair< std::size_t, std::size_t > > >, Teuchos::RCP< std::vector< unsigned int > > > getPeriodicNodePairing() const
Definition Panzer_STK_Interface.cpp:1826
panzer_stk::STK_Interface::setFaceFieldData
void setFaceFieldData(const std::string &fieldName, const std::string &blockId, const std::vector< std::size_t > &localFaceIds, const ArrayT &faceValues, double scaleValue=1.0)
Definition Panzer_STK_Interface.hpp:1762
panzer_stk::STK_Interface::isValid
bool isValid(stk::mesh::Entity entity) const
Definition Panzer_STK_Interface.hpp:866
panzer_stk::STK_Interface::getPeriodicBCVector
const std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > & getPeriodicBCVector() const
Definition Panzer_STK_Interface.hpp:1234
panzer_stk::STK_Interface::initialize
void initialize(stk::ParallelMachine parallelMach, bool setupIO=true, const bool buildRefinementSupport=false)
Definition Panzer_STK_Interface.cpp:259
panzer_stk::STK_Interface::SolutionFieldType
stk::mesh::Field< double > SolutionFieldType
Definition Panzer_STK_Interface.hpp:76
panzer_stk::STK_Interface::getMyFaces
void getMyFaces(std::vector< stk::mesh::Entity > &faces) const
Definition Panzer_STK_Interface.cpp:1220
panzer_stk::STK_Interface::getElementBlockPart
stk::mesh::Part * getElementBlockPart(const std::string &name) const
get the block part
Definition Panzer_STK_Interface.hpp:705
panzer_stk::STK_Interface::dimension_
unsigned dimension_
Definition Panzer_STK_Interface.hpp:1527
panzer_stk::STK_Interface::edgesString
static const std::string edgesString
Definition Panzer_STK_Interface.hpp:1421
panzer_stk::STK_Interface::addGlobalToExodus
void addGlobalToExodus(const std::string &key, const int &value)
Add an int global variable to the information to be written to the Exodus output file.
Definition Panzer_STK_Interface.cpp:846
panzer_stk::STK_Interface::getCurrentStateTime
double getCurrentStateTime() const
Definition Panzer_STK_Interface.hpp:1293
panzer_stk::STK_Interface::edgeBlockString
static const std::string edgeBlockString
Definition Panzer_STK_Interface.hpp:1422
panzer_stk::STK_Interface::getElementVertices
void getElementVertices(const std::vector< std::size_t > &localIds, ArrayT &vertices) const
Definition Panzer_STK_Interface.hpp:1785
panzer_stk::STK_Interface::getElementVertices_FromCoords
void getElementVertices_FromCoords(const std::vector< stk::mesh::Entity > &elements, ArrayT &vertices) const
Definition Panzer_STK_Interface.hpp:1917
panzer_stk::STK_Interface::getNumSidesets
std::size_t getNumSidesets() const
get the side set count
Definition Panzer_STK_Interface.hpp:729
panzer_stk::STK_Interface::orderedElementVector_
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedElementVector_
Definition Panzer_STK_Interface.hpp:1587
panzer_stk::STK_Interface::sidesets_
std::map< std::string, stk::mesh::Part * > sidesets_
Definition Panzer_STK_Interface.hpp:1497
panzer_stk::STK_Interface::addPeriodicBC
void addPeriodicBC(const Teuchos::RCP< const PeriodicBC_MatcherBase > &bc)
Definition Panzer_STK_Interface.hpp:1257
panzer_stk::STK_Interface::elementGlobalId
stk::mesh::EntityId elementGlobalId(std::size_t lid) const
Definition Panzer_STK_Interface.hpp:799
panzer_stk::STK_Interface::getEdgeBlock
stk::mesh::Part * getEdgeBlock(const std::string &name) const
get the block part
Definition Panzer_STK_Interface.hpp:713
panzer_stk::STK_Interface::localFaceIDHash_
std::unordered_map< stk::mesh::EntityId, std::size_t > localFaceIDHash_
Definition Panzer_STK_Interface.hpp:1600
panzer_stk::STK_Interface::getElementsSharingNodes
void getElementsSharingNodes(const std::vector< stk::mesh::EntityId > nodeId, std::vector< stk::mesh::Entity > &elements) const
get a set of elements sharing multiple nodes
Definition Panzer_STK_Interface.cpp:957
panzer_stk::STK_Interface::getEntityCounts
std::size_t getEntityCounts(unsigned entityRank) const
get the global counts for the entity of specified rank
Definition Panzer_STK_Interface.cpp:1042
panzer_stk::STK_Interface::getElementNodes
void getElementNodes(const std::vector< std::size_t > &localIds, ArrayT &nodes) const
Definition Panzer_STK_Interface.hpp:2114
panzer_stk::STK_Interface::getFaceBlockNames
void getFaceBlockNames(std::vector< std::string > &names) const
Definition Panzer_STK_Interface.cpp:1409
panzer_stk::STK_Interface::isFaceLocal
bool isFaceLocal(stk::mesh::Entity face) const
Definition Panzer_STK_Interface.cpp:1463
panzer_stk::STK_Interface::initializeFromMetaData
void initializeFromMetaData()
Definition Panzer_STK_Interface.cpp:1675
panzer_stk::STK_Interface::addEntityToEdgeBlock
void addEntityToEdgeBlock(stk::mesh::Entity entity, stk::mesh::Part *edgeblock)
Definition Panzer_STK_Interface.cpp:466
panzer_stk::STK_Interface::getElementsOrderedByLID
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getElementsOrderedByLID() const
Definition Panzer_STK_Interface.cpp:1554
panzer_stk::STK_Interface::isInitialized
bool isInitialized() const
Returns true if initialize been called on this mesh object.
Definition Panzer_STK_Interface.hpp:905
panzer_stk::STK_Interface::faceBlocks_
std::map< std::string, stk::mesh::Part * > faceBlocks_
Definition Panzer_STK_Interface.hpp:1500
panzer_stk::STK_Interface::addEntitiesToFaceBlock
void addEntitiesToFaceBlock(std::vector< stk::mesh::Entity > entities, stk::mesh::Part *faceblock)
Definition Panzer_STK_Interface.cpp:490
panzer_stk::STK_Interface::getNodeRank
stk::mesh::EntityRank getNodeRank() const
Get the STK entity rank corresponding to nodes.
Definition Panzer_STK_Interface.hpp:1213
panzer_stk::STK_Interface::addInformationRecords
void addInformationRecords(const std::vector< std::string > &info_records)
Definition Panzer_STK_Interface.cpp:254
panzer_stk::STK_Interface::initialized_
bool initialized_
Definition Panzer_STK_Interface.hpp:1529
panzer_stk::STK_Interface::containingBlockId
std::string containingBlockId(stk::mesh::Entity elmt) const
Definition Panzer_STK_Interface.cpp:1490
panzer_stk::STK_Interface::getEdgeBlockNames
void getEdgeBlockNames(std::vector< std::string > &names) const
Definition Panzer_STK_Interface.cpp:1399
panzer_stk::STK_Interface::addEdgeBlock
void addEdgeBlock(const std::string &elemBlockName, const std::string &edgeBlockName, const stk::topology &topology)
Definition Panzer_STK_Interface.cpp:1598
panzer_stk::STK_Interface::getElementVertices_FromField
void getElementVertices_FromField(const std::vector< stk::mesh::Entity > &elements, const std::string &eBlock, ArrayT &vertices) const
Definition Panzer_STK_Interface.hpp:2014
panzer_stk::STK_Interface::getFacesField
const VectorFieldType & getFacesField() const
Definition Panzer_STK_Interface.hpp:267
panzer_stk::STK_Interface::entityCounts_
std::vector< std::size_t > entityCounts_
Definition Panzer_STK_Interface.hpp:1532
panzer_stk::STK_Interface::getElementsSharingNode
void getElementsSharingNode(stk::mesh::EntityId nodeId, std::vector< stk::mesh::Entity > &elements) const
get a set of elements sharing a single node
Definition Panzer_STK_Interface.cpp:906
panzer_stk::STK_Interface::getElementNodes_FromCoords
void getElementNodes_FromCoords(const std::vector< stk::mesh::Entity > &elements, ArrayT &nodes) const
Definition Panzer_STK_Interface.hpp:2246
panzer_stk::STK_Interface::getEdgesOrderedByLID
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getEdgesOrderedByLID() const
Definition Panzer_STK_Interface.cpp:1585
panzer_stk::STK_Interface::currentStateTime_
double currentStateTime_
Definition Panzer_STK_Interface.hpp:1543
panzer_stk::STK_Interface::buildSubcells
void buildSubcells()
force the mesh to build subcells: edges and faces
Definition Panzer_STK_Interface.cpp:1058
panzer_stk::STK_Interface::setCellFieldData
void setCellFieldData(const std::string &fieldName, const std::string &blockId, const std::vector< std::size_t > &localElementIds, const ArrayT &solutionValues, double scaleValue=1.0)
Definition Panzer_STK_Interface.hpp:1720
panzer_stk::STK_Interface::getMaxEntityId
stk::mesh::EntityId getMaxEntityId(unsigned entityRank) const
get max entity ID of type entityRank
Definition Panzer_STK_Interface.cpp:1050
panzer_stk::STK_Interface::getPeriodicBCVector
std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > & getPeriodicBCVector()
Definition Panzer_STK_Interface.hpp:1240
panzer_stk::STK_Interface::getElementRank
stk::mesh::EntityRank getElementRank() const
Get the STK entity rank corresponding to elements.
Definition Panzer_STK_Interface.hpp:1205
panzer_stk::STK_Interface::currentLocalId_
std::size_t currentLocalId_
Definition Panzer_STK_Interface.hpp:1538
panzer_stk::STK_Interface::getOwnedElementsSharingNode
void getOwnedElementsSharingNode(stk::mesh::Entity node, std::vector< stk::mesh::Entity > &elements, std::vector< int > &relIds) const
Definition Panzer_STK_Interface.cpp:919
panzer_stk::STK_Interface::getNodeCoordinates
const double * getNodeCoordinates(stk::mesh::EntityId nodeId) const
Definition Panzer_STK_Interface.cpp:1071
panzer_stk::STK_Interface::getNodeIdsForElement
void getNodeIdsForElement(stk::mesh::Entity element, std::vector< stk::mesh::EntityId > &nodeIds) const
get a list of node ids for nodes connected to an element
Definition Panzer_STK_Interface.cpp:989
panzer_stk::STK_Interface::setBlockWeight
void setBlockWeight(const std::string &blockId, double weight)
Definition Panzer_STK_Interface.hpp:1315
panzer_stk::STK_Interface::addEdgeField
void addEdgeField(const std::string &fieldName, const std::string &blockId)
Definition Panzer_STK_Interface.cpp:168
panzer_stk::STK_Interface::faceGlobalId
stk::mesh::EntityId faceGlobalId(stk::mesh::Entity face) const
Definition Panzer_STK_Interface.hpp:856
panzer_stk::STK_Interface::localEdgeIDHash_
std::unordered_map< stk::mesh::EntityId, std::size_t > localEdgeIDHash_
Definition Panzer_STK_Interface.hpp:1599
panzer_stk::STK_Interface::addEntityToFaceBlock
void addEntityToFaceBlock(stk::mesh::Entity entity, stk::mesh::Part *faceblock)
Definition Panzer_STK_Interface.cpp:483
panzer_stk::STK_Interface::getNeighborElements
void getNeighborElements(std::vector< stk::mesh::Entity > &elements) const
Definition Panzer_STK_Interface.cpp:1128
panzer_stk::STK_Interface::getMyNodes
void getMyNodes(const std::string &sideName, const std::string &blockName, std::vector< stk::mesh::Entity > &nodes) const
Definition Panzer_STK_Interface.cpp:1348
panzer_stk::STK_Interface::edgesPartVec_
std::vector< stk::mesh::Part * > edgesPartVec_
Definition Panzer_STK_Interface.hpp:1508
panzer_stk::STK_Interface::isModifiable
bool isModifiable() const
Returns true if the bulk data manager is currently in modification mode (i.e. between beginModificati...
Definition Panzer_STK_Interface.hpp:643
panzer_stk::STK_Interface::useBoundingBoxSearch
const bool & useBoundingBoxSearch() const
Definition Panzer_STK_Interface.hpp:1245
panzer_stk::STK_Interface::setEdgeFieldData
void setEdgeFieldData(const std::string &fieldName, const std::string &blockId, const std::vector< std::size_t > &localEdgeIds, const ArrayT &edgeValues, double scaleValue=1.0)
Definition Panzer_STK_Interface.hpp:1741
panzer_stk::STK_Interface::initialStateTime_
double initialStateTime_
Definition Panzer_STK_Interface.hpp:1542
panzer_stk::STK_Interface::buildLocalEdgeIDs
void buildLocalEdgeIDs()
Definition Panzer_STK_Interface.cpp:1763
panzer_stk::STK_Interface::addEntityToNodeset
void addEntityToNodeset(stk::mesh::Entity entity, stk::mesh::Part *nodeset)
Definition Panzer_STK_Interface.cpp:458
panzer_stk::STK_Interface::getElementVerticesNoResize
void getElementVerticesNoResize(const std::vector< std::size_t > &localIds, ArrayT &vertices) const
Definition Panzer_STK_Interface.hpp:1851
panzer_stk::STK_Interface::addElement
void addElement(const Teuchos::RCP< ElementDescriptor > &ed, stk::mesh::Part *block)
Adds an element (described by its global ID and node IDs) into the given element block part.
Definition Panzer_STK_Interface.cpp:500
panzer_stk::STK_Interface::isEdgeLocal
bool isEdgeLocal(stk::mesh::Entity edge) const
Definition Panzer_STK_Interface.cpp:1437
panzer_stk::STK_Interface::addPeriodicBCs
void addPeriodicBCs(const std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > &bc_vec)
Definition Panzer_STK_Interface.hpp:1265
panzer_stk::STK_Interface::refineMesh
void refineMesh(const int numberOfLevels, const bool deleteParentElements)
Definition Panzer_STK_Interface.cpp:2024
panzer_stk::STK_Interface::nodesPart_
stk::mesh::Part * nodesPart_
Definition Panzer_STK_Interface.hpp:1505
panzer_stk::STK_Interface::facesPart_
stk::mesh::Part * facesPart_
Definition Panzer_STK_Interface.hpp:1509
panzer_stk::STK_Interface::blockWeights_
std::map< std::string, double > blockWeights_
Definition Panzer_STK_Interface.hpp:1596
panzer_stk::STK_Interface::fieldNameToEdgeField_
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToEdgeField_
Definition Panzer_STK_Interface.hpp:1521
panzer_stk::STK_Interface::addNode
void addNode(stk::mesh::EntityId gid, const std::vector< double > &coord)
Definition Panzer_STK_Interface.cpp:432
panzer_stk::STK_Interface::getComm
Teuchos::RCP< const Teuchos::Comm< int > > getComm() const
get the comm associated with this mesh
Definition Panzer_STK_Interface.cpp:2018
panzer_stk::STK_Interface::getElementNodesNoResize
void getElementNodesNoResize(const std::vector< std::size_t > &localIds, ArrayT &nodes) const
Definition Panzer_STK_Interface.hpp:2180
panzer_stk::STK_Interface::fieldNameToFaceField_
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToFaceField_
Definition Panzer_STK_Interface.hpp:1522
panzer_stk::STK_Interface::setSolutionFieldData
void setSolutionFieldData(const std::string &fieldName, const std::string &blockId, const std::vector< std::size_t > &localElementIds, const ArrayT &solutionValues, double scaleValue=1.0)
Definition Panzer_STK_Interface.hpp:1628
panzer_stk::STK_Interface::elementLocalId
std::size_t elementLocalId(stk::mesh::Entity elmt) const
Definition Panzer_STK_Interface.cpp:1419
panzer_stk::STK_Interface::VectorFieldType
stk::mesh::Field< double > VectorFieldType
Definition Panzer_STK_Interface.hpp:77
panzer_stk::STK_Interface::addCellField
void addCellField(const std::string &fieldName, const std::string &blockId)
Definition Panzer_STK_Interface.cpp:148
panzer_stk::STK_Interface::setInitialStateTime
void setInitialStateTime(double value)
Definition Panzer_STK_Interface.hpp:1306
panzer_stk::STK_Interface::buildLocalFaceIDs
void buildLocalFaceIDs()
Definition Panzer_STK_Interface.cpp:1783
panzer_stk::STK_Interface::getSolutionField
stk::mesh::Field< double > * getSolutionField(const std::string &fieldName, const std::string &blockId) const
Definition Panzer_STK_Interface.cpp:1498
panzer_stk::STK_Interface::fieldNameToSolution_
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToSolution_
Definition Panzer_STK_Interface.hpp:1519
panzer_stk::STK_Interface::getAllSides
void getAllSides(const std::string &sideName, std::vector< stk::mesh::Entity > &sides) const
Definition Panzer_STK_Interface.cpp:1319
panzer_stk::STK_Interface::coordinatesField_
VectorFieldType * coordinatesField_
Definition Panzer_STK_Interface.hpp:1512
panzer_stk::STK_Interface::edgesPart_
stk::mesh::Part * edgesPart_
Definition Panzer_STK_Interface.hpp:1507
panzer_stk::STK_Interface::getElementVertices_FromFieldNoResize
void getElementVertices_FromFieldNoResize(const std::vector< stk::mesh::Entity > &elements, const std::string &eBlock, ArrayT &vertices) const
but the vertex array will not be resized.
Definition Panzer_STK_Interface.hpp:2067
panzer_stk::STK_Interface::getMySides
void getMySides(const std::string &sideName, std::vector< stk::mesh::Entity > &sides) const
Definition Panzer_STK_Interface.cpp:1289
panzer_stk::STK_Interface::getInitialStateTime
double getInitialStateTime() const
Definition Panzer_STK_Interface.hpp:1300
panzer_stk::STK_Interface::addMeshCoordFields
void addMeshCoordFields(const std::string &blockId, const std::vector< std::string > &coordField, const std::string &dispPrefix)
Definition Panzer_STK_Interface.cpp:210
panzer_stk::STK_Interface::getEdgeField
stk::mesh::Field< double > * getEdgeField(const std::string &fieldName, const std::string &blockId) const
Definition Panzer_STK_Interface.cpp:1526
panzer_stk::STK_Interface::maxEntityId_
std::vector< stk::mesh::EntityId > maxEntityId_
Definition Panzer_STK_Interface.hpp:1535
panzer_stk::STK_Interface::getElementNodes_FromField
void getElementNodes_FromField(const std::vector< stk::mesh::Entity > &elements, const std::string &eBlock, ArrayT &nodes) const
Definition Panzer_STK_Interface.hpp:2343
panzer_stk::STK_Interface::getElementBlockNames
void getElementBlockNames(std::vector< std::string > &names) const
Definition Panzer_STK_Interface.cpp:1365
panzer_stk::STK_Interface::bulkData_
Teuchos::RCP< stk::mesh::BulkData > bulkData_
Definition Panzer_STK_Interface.hpp:1490
panzer_stk::STK_Interface::addNodeset
void addNodeset(const std::string &name)
Definition Panzer_STK_Interface.cpp:115
panzer_stk::STK_Interface::getSidesetNames
void getSidesetNames(std::vector< std::string > &name) const
Definition Panzer_STK_Interface.cpp:1377
panzer_stk::STK_Interface::addSideset
void addSideset(const std::string &name, const CellTopologyData *ctData)
Definition Panzer_STK_Interface.cpp:103
panzer_stk::STK_Interface::getFaceRank
stk::mesh::EntityRank getFaceRank() const
Get the STK entity rank corresponding to faces.
Definition Panzer_STK_Interface.hpp:1209
panzer_stk::STK_Interface::getMyEdges
void getMyEdges(std::vector< stk::mesh::Entity > &edges) const
Definition Panzer_STK_Interface.cpp:1152
panzer_stk::STK_Interface::getNumNodesets
std::size_t getNumNodesets() const
get the side set count
Definition Panzer_STK_Interface.hpp:739
panzer_stk::STK_Interface::getUseFieldCoordinates
bool getUseFieldCoordinates() const
Definition Panzer_STK_Interface.hpp:1328
panzer_stk::STK_Interface::useBBoxSearch_
bool useBBoxSearch_
Definition Panzer_STK_Interface.hpp:1487
panzer_stk::STK_Interface::informationRecords_
std::set< std::string > informationRecords_
Definition Panzer_STK_Interface.hpp:1525
panzer_stk::STK_Interface::getAllEdges
void getAllEdges(const std::string &edgeBlockName, std::vector< stk::mesh::Entity > &edges) const
Definition Panzer_STK_Interface.cpp:1191
panzer_stk::STK_Interface::nodesPartVec_
std::vector< stk::mesh::Part * > nodesPartVec_
Definition Panzer_STK_Interface.hpp:1506
panzer_stk::STK_Interface::getElementNodes_FromFieldNoResize
void getElementNodes_FromFieldNoResize(const std::vector< stk::mesh::Entity > &elements, const std::string &eBlock, ArrayT &nodes) const
but the node array will not be resized.
Definition Panzer_STK_Interface.hpp:2397
panzer_stk::STK_Interface::initializeFieldsInSTK
void initializeFieldsInSTK(const std::map< std::pair< std::string, std::string >, SolutionFieldType * > &nameToField, bool setupIO)
Definition Panzer_STK_Interface.cpp:367
panzer_stk::STK_Interface::nodesString
static const std::string nodesString
Definition Panzer_STK_Interface.hpp:1420
panzer_stk::STK_Interface::getCoordinatesField
const VectorFieldType & getCoordinatesField() const
Definition Panzer_STK_Interface.hpp:258
panzer_stk::STK_Interface::setUseFieldCoordinates
void setUseFieldCoordinates(bool useFieldCoordinates)
Definition Panzer_STK_Interface.hpp:1324
panzer_stk::STK_Interface::getMetaData
Teuchos::RCP< stk::mesh::MetaData > getMetaData() const
Returns the underlying STK meta data object.
Definition Panzer_STK_Interface.hpp:631
panzer_stk::STK_Interface::getFaceField
stk::mesh::Field< double > * getFaceField(const std::string &fieldName, const std::string &blockId) const
Definition Panzer_STK_Interface.cpp:1540
panzer_stk::STK_Interface::facesString
static const std::string facesString
Definition Panzer_STK_Interface.hpp:1424
panzer_stk::STK_Interface::writeToExodus
void writeToExodus(const std::string &filename, const bool append=false)
Write this mesh and associated fields to the given output file.
Definition Panzer_STK_Interface.cpp:602
panzer_stk::STK_Interface::getDimension
unsigned getDimension() const
get the dimension
Definition Panzer_STK_Interface.hpp:648
panzer_stk::STK_Interface::isMeshCoordField
bool isMeshCoordField(const std::string &eBlock, const std::string &fieldName, int &axis) const
Definition Panzer_STK_Interface.cpp:1804
panzer_stk::STK_Interface::nodesets_
std::map< std::string, stk::mesh::Part * > nodesets_
Definition Panzer_STK_Interface.hpp:1498
panzer_stk::STK_Interface::getElementVertices_FromCoordsNoResize
void getElementVertices_FromCoordsNoResize(const std::vector< stk::mesh::Entity > &elements, ArrayT &vertices) const
but the vertex array will not be resized.
Definition Panzer_STK_Interface.hpp:1968
panzer_stk::STK_Interface::buildEntityCounts
void buildEntityCounts()
Definition Panzer_STK_Interface.cpp:1000
panzer_stk::STK_Interface::loadBalField_
SolutionFieldType * loadBalField_
Definition Panzer_STK_Interface.hpp:1516
panzer_stk::STK_Interface::meshCoordFields_
std::map< std::string, std::vector< std::string > > meshCoordFields_
Definition Panzer_STK_Interface.hpp:1605
panzer_stk::STK_Interface::getCellField
stk::mesh::Field< double > * getCellField(const std::string &fieldName, const std::string &blockId) const
Definition Panzer_STK_Interface.cpp:1512
panzer_stk::STK_Interface::faceLocalId
std::size_t faceLocalId(stk::mesh::Entity elmt) const
Definition Panzer_STK_Interface.cpp:1477
panzer_stk::STK_Interface::getAllFaces
void getAllFaces(const std::string &faceBlockName, std::vector< stk::mesh::Entity > &faces) const
Definition Panzer_STK_Interface.cpp:1260
panzer_stk::STK_Interface::setupExodusFile
void setupExodusFile(const std::string &filename, const bool append=false, const bool append_after_restart_time=false, const double restart_time=0.0)
Set up an output Exodus file for writing results.
Definition Panzer_STK_Interface.cpp:616
panzer_stk::STK_Interface::orderedEdgeVector_
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedEdgeVector_
Definition Panzer_STK_Interface.hpp:1590
panzer_stk::STK_Interface::getNodeset
stk::mesh::Part * getNodeset(const std::string &name) const
Definition Panzer_STK_Interface.hpp:742
panzer_stk::STK_Interface::ProcIdData
double ProcIdData
Definition Panzer_STK_Interface.hpp:75
panzer_stk::STK_Interface::getCellTopology
Teuchos::RCP< const shards::CellTopology > getCellTopology(const std::string &eBlock) const
Definition Panzer_STK_Interface.cpp:1962
panzer_stk::STK_Interface::endModification
void endModification(const bool find_and_set_shared_nodes_in_stk=true)
Definition Panzer_STK_Interface.cpp:409
panzer_stk::STK_Interface::edgeGlobalId
stk::mesh::EntityId edgeGlobalId(std::size_t lid) const
Definition Panzer_STK_Interface.hpp:825
panzer_stk::STK_Interface::entityOwnerRank
unsigned entityOwnerRank(stk::mesh::Entity entity) const
Definition Panzer_STK_Interface.hpp:861
panzer_stk::STK_Interface::getNodesetNames
void getNodesetNames(std::vector< std::string > &name) const
Definition Panzer_STK_Interface.cpp:1389
panzer_stk::STK_Interface::addEntitiesToEdgeBlock
void addEntitiesToEdgeBlock(std::vector< stk::mesh::Entity > entities, stk::mesh::Part *edgeblock)
Definition Panzer_STK_Interface.cpp:473
panzer_stk::STK_Interface::ProcIdFieldType
stk::mesh::Field< ProcIdData > ProcIdFieldType
Definition Panzer_STK_Interface.hpp:78
panzer_stk::STK_Interface::getUseLowerCaseForIO
bool getUseLowerCaseForIO() const
Definition Panzer_STK_Interface.hpp:1336
panzer_stk::STK_Interface::localIDHash_
std::unordered_map< stk::mesh::EntityId, std::size_t > localIDHash_
Definition Panzer_STK_Interface.hpp:1598
panzer_stk::STK_Interface::addSolutionField
void addSolutionField(const std::string &fieldName, const std::string &blockId)
Definition Panzer_STK_Interface.cpp:129
panzer_stk::STK_Interface::edgesField_
VectorFieldType * edgesField_
Definition Panzer_STK_Interface.hpp:1513
panzer_stk::STK_Interface::getSubcellIndices
void getSubcellIndices(unsigned entityRank, stk::mesh::EntityId elementId, std::vector< stk::mesh::EntityId > &subcellIds) const
Definition Panzer_STK_Interface.cpp:1082
panzer_stk::STK_Interface::periodicBCs_
std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > periodicBCs_
Definition Panzer_STK_Interface.hpp:1486
panzer_stk::STK_Interface::addEntityToSideset
void addEntityToSideset(stk::mesh::Entity entity, stk::mesh::Part *sideset)
Definition Panzer_STK_Interface.cpp:450
panzer_stk::STK_Interface::getFacesOrderedByLID
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getFacesOrderedByLID() const
Definition Panzer_STK_Interface.cpp:1630
panzer_stk::STK_Interface::buildMaxEntityIds
void buildMaxEntityIds()
Definition Panzer_STK_Interface.cpp:1006
panzer_stk::STK_Interface::setDispFieldData
void setDispFieldData(const std::string &fieldName, const std::string &blockId, int axis, const std::vector< std::size_t > &localElementIds, const ArrayT &solutionValues)
Definition Panzer_STK_Interface.hpp:1661
panzer_stk::STK_Interface::elementGlobalId
stk::mesh::EntityId elementGlobalId(stk::mesh::Entity elmt) const
Definition Panzer_STK_Interface.hpp:804
panzer_stk::STK_Interface::elementBlockCT_
std::map< std::string, Teuchos::RCP< shards::CellTopology > > elementBlockCT_
Definition Panzer_STK_Interface.hpp:1502
panzer_stk::STK_Interface::getSideRank
stk::mesh::EntityRank getSideRank() const
Get the STK entity rank corresponding to sides (dimension one lower than element rank).
Definition Panzer_STK_Interface.hpp:1207
panzer_stk::STK_Interface::mpiComm_
Teuchos::RCP< Teuchos::MpiComm< int > > mpiComm_
Definition Panzer_STK_Interface.hpp:1540
panzer_stk::STK_Interface::processorIdField_
ProcIdFieldType * processorIdField_
Definition Panzer_STK_Interface.hpp:1515
panzer_stk::STK_Interface::validBlockId
bool validBlockId(const std::string &blockId) const
Definition Panzer_STK_Interface.cpp:1865
panzer_stk::STK_Interface::edgeGlobalId
stk::mesh::EntityId edgeGlobalId(stk::mesh::Entity edge) const
Definition Panzer_STK_Interface.hpp:830
panzer_stk::STK_Interface::addFaceField
void addFaceField(const std::string &fieldName, const std::string &blockId)
Definition Panzer_STK_Interface.cpp:189
panzer_stk::STK_Interface::edgeBlocks_
std::map< std::string, stk::mesh::Part * > edgeBlocks_
Definition Panzer_STK_Interface.hpp:1499
panzer_stk::STK_Interface::print
void print(std::ostream &os) const
Definition Panzer_STK_Interface.cpp:1872
panzer_stk::STK_Interface::STK_Interface
STK_Interface()
Construct with no spatial dimension set. addElementBlock() and initialize() must be used to set it up...
Definition Panzer_STK_Interface.cpp:77
panzer_stk::STK_Interface::getMyElements
void getMyElements(std::vector< stk::mesh::Entity > &elements) const
Definition Panzer_STK_Interface.cpp:1103
panzer_stk::STK_Interface::getOwnedPart
stk::mesh::Part * getOwnedPart() const
Get a pointer to the locally owned part.
Definition Panzer_STK_Interface.hpp:701
panzer_stk::STK_Interface::addElementBlock
void addElementBlock(const std::string &name, const CellTopologyData *ctData)
Definition Panzer_STK_Interface.cpp:1567
panzer_stk::STK_Interface::getProcessorIdField
ProcIdFieldType * getProcessorIdField()
Get the field holding each entity's owning processor rank.
Definition Panzer_STK_Interface.hpp:902
panzer_stk::STK_Interface::isWritable
bool isWritable() const
Returns true if the mesh can be written out to Exodus (i.e. is IOSS/output set up)?
Definition Panzer_STK_Interface.cpp:897
panzer_stk::STK_Interface::addFaceBlock
void addFaceBlock(const std::string &elemBlockName, const std::string &faceBlockName, const stk::topology &topology)
Definition Panzer_STK_Interface.cpp:1643
panzer_stk::STK_Interface::getBulkData
Teuchos::RCP< stk::mesh::BulkData > getBulkData() const
Returns the underlying STK bulk data object.
Definition Panzer_STK_Interface.hpp:629
panzer_stk::STK_Interface::addFaces
void addFaces()
Builds face entities for the mesh from its existing elements.
Definition Panzer_STK_Interface.cpp:551
panzer_stk::STK_Interface::meshDispFields_
std::map< std::string, std::vector< std::string > > meshDispFields_
Definition Panzer_STK_Interface.hpp:1606
panzer_stk::STK_Interface::faceBlockString
static const std::string faceBlockString
Definition Panzer_STK_Interface.hpp:1423
panzer_stk::STK_Interface::facesPartVec_
std::vector< stk::mesh::Part * > facesPartVec_
Definition Panzer_STK_Interface.hpp:1510
panzer_stk::STK_Interface::useFieldCoordinates_
bool useFieldCoordinates_
Definition Panzer_STK_Interface.hpp:1608
panzer_stk::STK_Interface::printMetaData
void printMetaData(std::ostream &os) const
Definition Panzer_STK_Interface.cpp:1922
panzer_stk::STK_Interface::instantiateBulkData
void instantiateBulkData(stk::ParallelMachine parallelMach)
Definition Panzer_STK_Interface.cpp:391
panzer_stk::STK_Interface::useLowerCase_
bool useLowerCase_
Definition Panzer_STK_Interface.hpp:1610
panzer_stk::STK_Interface::getElementNodes_FromCoordsNoResize
void getElementNodes_FromCoordsNoResize(const std::vector< stk::mesh::Entity > &elements, ArrayT &nodes) const
but the node array will not be resized.
Definition Panzer_STK_Interface.hpp:2297
panzer_stk::STK_Interface::faceGlobalId
stk::mesh::EntityId faceGlobalId(std::size_t lid) const
Definition Panzer_STK_Interface.hpp:851
panzer_stk::STK_Interface::fieldNameToCellField_
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToCellField_
Definition Panzer_STK_Interface.hpp:1520
panzer_stk::STK_Interface::edgeLocalId
std::size_t edgeLocalId(stk::mesh::Entity elmt) const
Definition Panzer_STK_Interface.cpp:1451
panzer_stk::STK_Interface::elementBlocks_
std::map< std::string, stk::mesh::Part * > elementBlocks_
Definition Panzer_STK_Interface.hpp:1496
panzer_stk::STK_Interface::procRank_
unsigned procRank_
Definition Panzer_STK_Interface.hpp:1537
panzer_stk::STK_Interface::coordsString
static const std::string coordsString
Definition Panzer_STK_Interface.hpp:1419
panzer_stk::STK_Interface::getSolutionFieldData
void getSolutionFieldData(const std::string &fieldName, const std::string &blockId, const std::vector< std::size_t > &localElementIds, ArrayT &solutionValues) const
Definition Panzer_STK_Interface.hpp:1690
panzer_stk::STK_Interface::setUseLowerCaseForIO
void setUseLowerCaseForIO(bool useLowerCase)
Definition Panzer_STK_Interface.hpp:1332
panzer_stk::STK_Interface::getSafeCommunicator
Teuchos::RCP< Teuchos::MpiComm< int > > getSafeCommunicator(stk::ParallelMachine parallelMach) const
Definition Panzer_STK_Interface.cpp:1978
panzer_stk::STK_Interface::getNumElementBlocks
std::size_t getNumElementBlocks() const
get the block count
Definition Panzer_STK_Interface.hpp:652
panzer_stk::STK_Interface::setBoundingBoxSearchFlag
void setBoundingBoxSearchFlag(const bool &searchFlag)
Definition Panzer_STK_Interface.hpp:1249
panzer_stk::STK_Interface::getFaceBlock
stk::mesh::Part * getFaceBlock(const std::string &name) const
get the block part
Definition Panzer_STK_Interface.hpp:721
panzer_stk::STK_Interface::getEdgeRank
stk::mesh::EntityRank getEdgeRank() const
Get the STK entity rank corresponding to edges.
Definition Panzer_STK_Interface.hpp:1211
panzer_stk::STK_Interface::getSideset
stk::mesh::Part * getSideset(const std::string &name) const
Definition Panzer_STK_Interface.hpp:732
panzer_stk
Definition Panzer_STK_GatherExodusCellDataToIP.hpp:26
panzer_stk::buildElementDescriptor
Teuchos::RCP< ElementDescriptor > buildElementDescriptor(stk::mesh::EntityId elmtId, std::vector< stk::mesh::EntityId > &nodes)
Definition Panzer_STK_Interface.cpp:65
panzer_stk::STK_Interface::EdgeBlockException
Definition Panzer_STK_Interface.hpp:88
panzer_stk::STK_Interface::EdgeBlockException::EdgeBlockException
EdgeBlockException(const std::string &what)
Definition Panzer_STK_Interface.hpp:88
panzer_stk::STK_Interface::ElementBlockException
Definition Panzer_STK_Interface.hpp:82
panzer_stk::STK_Interface::ElementBlockException::ElementBlockException
ElementBlockException(const std::string &what)
Definition Panzer_STK_Interface.hpp:82
panzer_stk::STK_Interface::FaceBlockException
Definition Panzer_STK_Interface.hpp:91
panzer_stk::STK_Interface::FaceBlockException::FaceBlockException
FaceBlockException(const std::string &what)
Definition Panzer_STK_Interface.hpp:91
panzer_stk::STK_Interface::SidesetException
Definition Panzer_STK_Interface.hpp:85
panzer_stk::STK_Interface::SidesetException::SidesetException
SidesetException(const std::string &what)
Definition Panzer_STK_Interface.hpp:85
Generated by doxygen 1.9.8