Panzer  Version of the Day
Panzer_STK_CubeTetMeshFactory.cpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Panzer: A partial differential equation assembly
5 // engine for strongly coupled complex multiphysics systems
6 // Copyright (2011) Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and
39 // Eric C. Cyr (eccyr@sandia.gov)
40 // ***********************************************************************
41 // @HEADER
42 
44 #include <Teuchos_TimeMonitor.hpp>
45 #include <PanzerAdaptersSTK_config.hpp>
46 
47 using Teuchos::RCP;
48 using Teuchos::rcp;
49 
50 namespace panzer_stk {
51 
53 {
55 }
56 
59 {
60 }
61 
63 Teuchos::RCP<STK_Interface> CubeTetMeshFactory::buildMesh(stk::ParallelMachine parallelMach) const
64 {
65  PANZER_FUNC_TIME_MONITOR("panzer::CubeTetMeshFactory::buildMesh()");
66 
67  // build all meta data
68  RCP<STK_Interface> mesh = buildUncommitedMesh(parallelMach);
69 
70  // commit meta data
71  mesh->initialize(parallelMach);
72 
73  // build bulk data
74  completeMeshConstruction(*mesh,parallelMach);
75 
76  return mesh;
77 }
78 
80 {
81  PANZER_FUNC_TIME_MONITOR("panzer::CubeTetMeshFactory::buildUncomittedMesh()");
82 
83  RCP<STK_Interface> mesh = rcp(new STK_Interface(3));
84 
85  machRank_ = stk::parallel_machine_rank(parallelMach);
86  machSize_ = stk::parallel_machine_size(parallelMach);
87 
88  if(xProcs_==-1) {
89  // default x only decomposition
90  xProcs_ = machSize_;
91  yProcs_ = 1;
92  zProcs_ = 1;
93  }
95  "Cannot build CubeTetMeshFactory, the product of \"X Procs\", \"Y Procs\", and \"Z Procs\""
96  " must equal the number of processors.");
98 
99  // build meta information: blocks and side set setups
100  buildMetaData(parallelMach,*mesh);
101 
102  mesh->addPeriodicBCs(periodicBCVec_);
103 
104  return mesh;
105 }
106 
107 void CubeTetMeshFactory::completeMeshConstruction(STK_Interface & mesh,stk::ParallelMachine parallelMach) const
108 {
109  PANZER_FUNC_TIME_MONITOR("panzer::CubeTetMeshFactory::completeMeshConstruction()");
110 
111  if(not mesh.isInitialized())
112  mesh.initialize(parallelMach);
113 
114  // add node and element information
115  buildElements(parallelMach,mesh);
116 
117  // finish up the edges and faces
118  mesh.buildSubcells();
119  mesh.buildLocalElementIDs();
120 
121  // now that edges are built, sidets can be added
122  addSideSets(mesh);
123 
124  // calls Stk_MeshFactory::rebalance
125  this->rebalance(mesh);
126 }
127 
130 {
132 
133  setMyParamList(paramList);
134 
135  x0_ = paramList->get<double>("X0");
136  y0_ = paramList->get<double>("Y0");
137  z0_ = paramList->get<double>("Z0");
138 
139  xf_ = paramList->get<double>("Xf");
140  yf_ = paramList->get<double>("Yf");
141  zf_ = paramList->get<double>("Zf");
142 
143  xBlocks_ = paramList->get<int>("X Blocks");
144  yBlocks_ = paramList->get<int>("Y Blocks");
145  zBlocks_ = paramList->get<int>("Z Blocks");
146 
147  xProcs_ = paramList->get<int>("X Procs");
148  yProcs_ = paramList->get<int>("Y Procs");
149  zProcs_ = paramList->get<int>("Z Procs");
150 
151  nXElems_ = paramList->get<int>("X Elements");
152  nYElems_ = paramList->get<int>("Y Elements");
153  nZElems_ = paramList->get<int>("Z Elements");
154 
155  // read in periodic boundary conditions
156  parsePeriodicBCList(Teuchos::rcpFromRef(paramList->sublist("Periodic BCs")),periodicBCVec_);
157 }
158 
161 {
162  static RCP<Teuchos::ParameterList> defaultParams;
163 
164  // fill with default values
165  if(defaultParams == Teuchos::null) {
166  defaultParams = rcp(new Teuchos::ParameterList);
167 
168  defaultParams->set<double>("X0",0.0);
169  defaultParams->set<double>("Y0",0.0);
170  defaultParams->set<double>("Z0",0.0);
171 
172  defaultParams->set<double>("Xf",1.0);
173  defaultParams->set<double>("Yf",1.0);
174  defaultParams->set<double>("Zf",1.0);
175 
176  defaultParams->set<int>("X Blocks",1);
177  defaultParams->set<int>("Y Blocks",1);
178  defaultParams->set<int>("Z Blocks",1);
179 
180  defaultParams->set<int>("X Procs",-1);
181  defaultParams->set<int>("Y Procs",1);
182  defaultParams->set<int>("Z Procs",1);
183 
184  defaultParams->set<int>("X Elements",5);
185  defaultParams->set<int>("Y Elements",5);
186  defaultParams->set<int>("Z Elements",5);
187 
188  Teuchos::ParameterList & bcs = defaultParams->sublist("Periodic BCs");
189  bcs.set<int>("Count",0); // no default periodic boundary conditions
190  }
191 
192  return defaultParams;
193 }
194 
196 {
197  // get valid parameters
199 
200  // set that parameter list
201  setParameterList(validParams);
202 }
203 
204 void CubeTetMeshFactory::buildMetaData(stk::ParallelMachine parallelMach, STK_Interface & mesh) const
205 {
206  typedef shards::Tetrahedron<4> TetTopo;
207  const CellTopologyData * ctd = shards::getCellTopologyData<TetTopo>();
208  const CellTopologyData * side_ctd = shards::CellTopology(ctd).getBaseCellTopologyData(2,0);
209 
210  // build meta data
211  //mesh.setDimension(2);
212  for(int bx=0;bx<xBlocks_;bx++) {
213  for(int by=0;by<yBlocks_;by++) {
214  for(int bz=0;bz<zBlocks_;bz++) {
215 
216  std::stringstream ebPostfix;
217  ebPostfix << "-" << bx << "_" << by << "_" << bz;
218 
219  // add element blocks
220  mesh.addElementBlock("eblock"+ebPostfix.str(),ctd);
221  }
222  }
223  }
224 
225  // add sidesets
226  mesh.addSideset("left",side_ctd);
227  mesh.addSideset("right",side_ctd);
228  mesh.addSideset("top",side_ctd);
229  mesh.addSideset("bottom",side_ctd);
230  mesh.addSideset("front",side_ctd);
231  mesh.addSideset("back",side_ctd);
232 }
233 
234 void CubeTetMeshFactory::buildElements(stk::ParallelMachine parallelMach,STK_Interface & mesh) const
235 {
236  mesh.beginModification();
237  // build each block
238  for(int xBlock=0;xBlock<xBlocks_;xBlock++) {
239  for(int yBlock=0;yBlock<yBlocks_;yBlock++) {
240  for(int zBlock=0;zBlock<zBlocks_;zBlock++) {
241  buildBlock(parallelMach,xBlock,yBlock,zBlock,mesh);
242  }
243  }
244  }
245  mesh.endModification();
246 }
247 
248 void CubeTetMeshFactory::buildBlock(stk::ParallelMachine parallelMach,int xBlock,int yBlock,int zBlock,STK_Interface & mesh) const
249 {
250  // grab this processors rank and machine size
251  std::pair<int,int> sizeAndStartX = determineXElemSizeAndStart(xBlock,xProcs_,machRank_);
252  std::pair<int,int> sizeAndStartY = determineYElemSizeAndStart(yBlock,yProcs_,machRank_);
253  std::pair<int,int> sizeAndStartZ = determineZElemSizeAndStart(zBlock,zProcs_,machRank_);
254 
255  int myXElems_start = sizeAndStartX.first;
256  int myXElems_end = myXElems_start+sizeAndStartX.second;
257  int myYElems_start = sizeAndStartY.first;
258  int myYElems_end = myYElems_start+sizeAndStartY.second;
259  int myZElems_start = sizeAndStartZ.first;
260  int myZElems_end = myZElems_start+sizeAndStartZ.second;
261 
262  int totalXElems = nXElems_*xBlocks_;
263  int totalYElems = nYElems_*yBlocks_;
264  int totalZElems = nZElems_*zBlocks_;
265 
266  double deltaX = (xf_-x0_)/double(totalXElems);
267  double deltaY = (yf_-y0_)/double(totalYElems);
268  double deltaZ = (zf_-z0_)/double(totalZElems);
269 
270  std::vector<double> coord(3,0.0);
271 
272  // build the nodes
273  for(int nx=myXElems_start;nx<myXElems_end+1;++nx) {
274  coord[0] = double(nx)*deltaX+x0_;
275  for(int ny=myYElems_start;ny<myYElems_end+1;++ny) {
276  coord[1] = double(ny)*deltaY+y0_;
277  for(int nz=myZElems_start;nz<myZElems_end+1;++nz) {
278  coord[2] = double(nz)*deltaZ+z0_;
279 
280  mesh.addNode(nz*(totalYElems+1)*(totalXElems+1)+ny*(totalXElems+1)+nx+1,coord);
281  }
282  }
283  }
284 
285  std::stringstream blockName;
286  blockName << "eblock-" << xBlock << "_" << yBlock << "_" << zBlock;
287  stk::mesh::Part * block = mesh.getElementBlockPart(blockName.str());
288 
289  // build the elements
290  for(int nx=myXElems_start;nx<myXElems_end;++nx) {
291  for(int ny=myYElems_start;ny<myYElems_end;++ny) {
292  for(int nz=myZElems_start;nz<myZElems_end;++nz) {
293 
294  std::vector<stk::mesh::EntityId> nodes(8);
295  nodes[0] = nx+1+ny*(totalXElems+1) +nz*(totalYElems+1)*(totalXElems+1);
296  nodes[1] = nodes[0]+1;
297  nodes[2] = nodes[1]+(totalXElems+1);
298  nodes[3] = nodes[2]-1;
299  nodes[4] = nodes[0]+(totalYElems+1)*(totalXElems+1);
300  nodes[5] = nodes[1]+(totalYElems+1)*(totalXElems+1);
301  nodes[6] = nodes[2]+(totalYElems+1)*(totalXElems+1);
302  nodes[7] = nodes[3]+(totalYElems+1)*(totalXElems+1);
303 
304  buildTetsOnHex(Teuchos::tuple(totalXElems,totalYElems,totalZElems),
305  Teuchos::tuple(nx,ny,nz),
306  block,nodes,mesh);
307  }
308  }
309  }
310 }
311 
313  const Teuchos::Tuple<int,3> & element,
314  stk::mesh::Part * block,
315  const std::vector<stk::mesh::EntityId> & h_nodes,
316  STK_Interface & mesh) const
317 {
318  Teuchos::FancyOStream out(Teuchos::rcpFromRef(std::cout));
319  out.setShowProcRank(true);
320  out.setOutputToRootOnly(-1);
321 
322  int totalXElems = meshDesc[0]; int totalYElems = meshDesc[1]; int totalZElems = meshDesc[2];
323  int nx = element[0]; int ny = element[1]; int nz = element[2];
324 
325  stk::mesh::EntityId hex_id = totalXElems*totalYElems*nz+totalXElems*ny+nx+1;
326  stk::mesh::EntityId gid_0 = 12*(hex_id-1)+1;
327  std::vector<stk::mesh::EntityId> nodes(4);
328 
329  // add centroid node
330  stk::mesh::EntityId centroid = 0;
331  {
332  stk::mesh::EntityId largestNode = (totalXElems+1)*(totalYElems+1)*(totalZElems+1);
333  centroid = hex_id+largestNode;
334 
335  // compute average of coordinates
336  std::vector<double> coord(3,0.0);
337  for(std::size_t i=0;i<h_nodes.size();i++) {
338  const double * node_coord = mesh.getNodeCoordinates(h_nodes[i]);
339  coord[0] += node_coord[0];
340  coord[1] += node_coord[1];
341  coord[2] += node_coord[2];
342  }
343  coord[0] /= 8.0;
344  coord[1] /= 8.0;
345  coord[2] /= 8.0;
346 
347  mesh.addNode(centroid,coord);
348  }
349 
350  //
351  int idSet[][3] = { { 0, 1, 2}, // back
352  { 0, 2, 3},
353  { 0, 5, 1}, // bottom
354  { 0, 4, 5},
355  { 0, 7, 4}, // left
356  { 0, 3, 7},
357  { 6, 1, 5}, // right
358  { 6, 2, 1},
359  { 6, 3, 2}, // top
360  { 6, 7, 3},
361  { 6, 4, 7}, // front
362  { 6, 5, 4} };
363 
364  for(int i=0;i<12;i++) {
365  nodes[0] = h_nodes[idSet[i][0]];
366  nodes[1] = h_nodes[idSet[i][1]];
367  nodes[2] = h_nodes[idSet[i][2]];
368  nodes[3] = centroid;
369 
370  // add element to mesh
371  mesh.addElement(rcp(new ElementDescriptor(gid_0+i,nodes)),block);
372  }
373 }
374 
375 std::pair<int,int> CubeTetMeshFactory::determineXElemSizeAndStart(int xBlock,unsigned int size,unsigned int rank) const
376 {
377  std::size_t xProcLoc = procTuple_[0];
378  unsigned int minElements = nXElems_/size;
379  unsigned int extra = nXElems_ - minElements*size;
380 
381  TEUCHOS_ASSERT(minElements>0);
382 
383  // first "extra" elements get an extra column of elements
384  // this determines the starting X index and number of elements
385  int nume=0, start=0;
386  if(xProcLoc<extra) {
387  nume = minElements+1;
388  start = xProcLoc*(minElements+1);
389  }
390  else {
391  nume = minElements;
392  start = extra*(minElements+1)+(xProcLoc-extra)*minElements;
393  }
394 
395  return std::make_pair(start+nXElems_*xBlock,nume);
396 }
397 
398 std::pair<int,int> CubeTetMeshFactory::determineYElemSizeAndStart(int yBlock,unsigned int size,unsigned int rank) const
399 {
400  // int start = yBlock*nYElems_;
401  // return std::make_pair(start,nYElems_);
402 
403  std::size_t yProcLoc = procTuple_[1];
404  unsigned int minElements = nYElems_/size;
405  unsigned int extra = nYElems_ - minElements*size;
406 
407  TEUCHOS_ASSERT(minElements>0);
408 
409  // first "extra" elements get an extra column of elements
410  // this determines the starting X index and number of elements
411  int nume=0, start=0;
412  if(yProcLoc<extra) {
413  nume = minElements+1;
414  start = yProcLoc*(minElements+1);
415  }
416  else {
417  nume = minElements;
418  start = extra*(minElements+1)+(yProcLoc-extra)*minElements;
419  }
420 
421  return std::make_pair(start+nYElems_*yBlock,nume);
422 }
423 
424 std::pair<int,int> CubeTetMeshFactory::determineZElemSizeAndStart(int zBlock,unsigned int size,unsigned int rank) const
425 {
426  // int start = zBlock*nZElems_;
427  // return std::make_pair(start,nZElems_);
428  std::size_t zProcLoc = procTuple_[2];
429  unsigned int minElements = nZElems_/size;
430  unsigned int extra = nZElems_ - minElements*size;
431 
432  TEUCHOS_ASSERT(minElements>0);
433 
434  // first "extra" elements get an extra column of elements
435  // this determines the starting X index and number of elements
436  int nume=0, start=0;
437  if(zProcLoc<extra) {
438  nume = minElements+1;
439  start = zProcLoc*(minElements+1);
440  }
441  else {
442  nume = minElements;
443  start = extra*(minElements+1)+(zProcLoc-extra)*minElements;
444  }
445 
446  return std::make_pair(start+nZElems_*zBlock,nume);
447 }
448 
450 {
451  mesh.beginModification();
452  const stk::mesh::EntityRank side_rank = mesh.getSideRank();
453 
454  std::size_t totalXElems = nXElems_*xBlocks_;
455  std::size_t totalYElems = nYElems_*yBlocks_;
456  std::size_t totalZElems = nZElems_*zBlocks_;
457 
458  // get all part vectors
459  stk::mesh::Part * left = mesh.getSideset("left");
460  stk::mesh::Part * right = mesh.getSideset("right");
461  stk::mesh::Part * top = mesh.getSideset("top");
462  stk::mesh::Part * bottom = mesh.getSideset("bottom");
463  stk::mesh::Part * front = mesh.getSideset("front");
464  stk::mesh::Part * back = mesh.getSideset("back");
465 
466  std::vector<stk::mesh::Entity> localElmts;
467  mesh.getMyElements(localElmts);
468 
469  // gid = totalXElems*totalYElems*nz+totalXElems*ny+nx+1
470 
471  // loop over elements adding sides to sidesets
472  std::vector<stk::mesh::Entity>::const_iterator itr;
473  for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
474  stk::mesh::Entity element = (*itr);
475  stk::mesh::EntityId gid = mesh.elementGlobalId(element);
476 
477  // get hex global id
478  stk::mesh::EntityId h_gid = (gid-1)/12+1;
479  stk::mesh::EntityId t_offset = gid - (12*(h_gid-1)+1);
480 
481  std::size_t nx,ny,nz;
482  nz = (h_gid-1) / (totalXElems*totalYElems);
483  h_gid = (h_gid-1)-nz*(totalXElems*totalYElems);
484  ny = h_gid / totalXElems;
485  nx = h_gid-ny*totalXElems;
486 
487  if(nz==0 && (t_offset==0 || t_offset==1)) {
488  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
489 
490  // on the back
491  if(mesh.entityOwnerRank(side)==machRank_)
492  mesh.addEntityToSideset(side,back);
493  }
494  if(nz+1==totalZElems && (t_offset==10 || t_offset==11)) {
495  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
496 
497  // on the front
498  if(mesh.entityOwnerRank(side)==machRank_)
499  mesh.addEntityToSideset(side,front);
500  }
501 
502  if(ny==0 && (t_offset==2 || t_offset==3)) {
503  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
504 
505  // on the bottom
506  if(mesh.entityOwnerRank(side)==machRank_)
507  mesh.addEntityToSideset(side,bottom);
508  }
509  if(ny+1==totalYElems && (t_offset==8 || t_offset==9)) {
510  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
511 
512  // on the top
513  if(mesh.entityOwnerRank(side)==machRank_)
514  mesh.addEntityToSideset(side,top);
515  }
516 
517  if(nx==0 && (t_offset==4 || t_offset==5)) {
518  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
519 
520  // on the left
521  if(mesh.entityOwnerRank(side)==machRank_)
522  mesh.addEntityToSideset(side,left);
523  }
524  if(nx+1==totalXElems && (t_offset==6 || t_offset==7)) {
525  stk::mesh::Entity side = mesh.findConnectivityById(element, side_rank, 3);
526 
527  // on the right
528  if(mesh.entityOwnerRank(side)==machRank_)
529  mesh.addEntityToSideset(side,right);
530  }
531  }
532 
533  mesh.endModification();
534 }
535 
538 {
539  std::size_t i=0,j=0,k=0;
540 
541  k = procRank/(xProcs_*yProcs_); procRank = procRank % (xProcs_*yProcs_);
542  j = procRank/xProcs_; procRank = procRank % xProcs_;
543  i = procRank;
544 
545  return Teuchos::tuple(i,j,k);
546 }
547 
548 } // end panzer_stk
stk::mesh::Part * getElementBlockPart(const std::string &name) const
get the block count
void buildTetsOnHex(const Teuchos::Tuple< int, 3 > &meshDesc, const Teuchos::Tuple< int, 3 > &element, stk::mesh::Part *block, const std::vector< stk::mesh::EntityId > &h_nodes, STK_Interface &mesh) const
basic_FancyOStream & setShowProcRank(const bool showProcRank)
T & get(const std::string &name, T def_value)
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
From ParameterListAcceptor.
void getMyElements(std::vector< stk::mesh::Entity > &elements) const
void addEntityToSideset(stk::mesh::Entity entity, stk::mesh::Part *sideset)
Teuchos::RCP< STK_Interface > buildMesh(stk::ParallelMachine parallelMach) const
Build the mesh object.
void addSideSets(STK_Interface &mesh) const
stk::mesh::EntityRank getSideRank() const
void initialize(stk::ParallelMachine parallelMach, bool setupIO=true)
stk::mesh::Entity findConnectivityById(stk::mesh::Entity src, stk::mesh::EntityRank tgt_rank, unsigned rel_id) const
const double * getNodeCoordinates(stk::mesh::EntityId nodeId) const
std::pair< int, int > determineYElemSizeAndStart(int yBlock, unsigned int size, unsigned int rank) const
void buildElements(stk::ParallelMachine parallelMach, STK_Interface &mesh) const
stk::mesh::Part * getSideset(const std::string &name) const
void addElement(const Teuchos::RCP< ElementDescriptor > &ed, stk::mesh::Part *block)
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
stk::mesh::EntityId elementGlobalId(std::size_t lid) const
std::pair< int, int > determineZElemSizeAndStart(int zBlock, unsigned int size, unsigned int rank) const
void setMyParamList(const RCP< ParameterList > &paramList)
bool isInitialized() const
Has initialize been called on this mesh object?
virtual void completeMeshConstruction(STK_Interface &mesh, stk::ParallelMachine parallelMach) const
void validateParametersAndSetDefaults(ParameterList const &validParamList, int const depth=1000)
basic_FancyOStream & setOutputToRootOnly(const int rootRank)
void setParameterList(const Teuchos::RCP< Teuchos::ParameterList > &paramList)
From ParameterListAcceptor.
virtual Teuchos::RCP< STK_Interface > buildUncommitedMesh(stk::ParallelMachine parallelMach) const
void addNode(stk::mesh::EntityId gid, const std::vector< double > &coord)
void buildSubcells()
force the mesh to build subcells: edges and faces
void addSideset(const std::string &name, const CellTopologyData *ctData)
std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > periodicBCVec_
std::pair< int, int > determineXElemSizeAndStart(int xBlock, unsigned int size, unsigned int rank) const
Teuchos::Tuple< std::size_t, 3 > procRankToProcTuple(std::size_t procRank) const
what is the 3D tuple describe this processor distribution
void buildBlock(stk::ParallelMachine machRank, int xBlock, int yBlock, int zBlock, STK_Interface &mesh) const
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
unsigned entityOwnerRank(stk::mesh::Entity entity) const
void rebalance(STK_Interface &mesh) const
#define TEUCHOS_ASSERT(assertion_test)
void buildMetaData(stk::ParallelMachine parallelMach, STK_Interface &mesh) const
Teuchos::Tuple< std::size_t, 3 > procTuple_
void addElementBlock(const std::string &name, const CellTopologyData *ctData)
static void parsePeriodicBCList(const Teuchos::RCP< Teuchos::ParameterList > &pl, std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > &periodicBC)