FEI Version of the Day
Loading...
Searching...
No Matches
SNL_FEI_Structure.hpp
1#ifndef _SNL_FEI_Structure_hpp_
2#define _SNL_FEI_Structure_hpp_
3
4/*--------------------------------------------------------------------*/
5/* Copyright 2005 Sandia Corporation. */
6/* Under the terms of Contract DE-AC04-94AL85000, there is a */
7/* non-exclusive license for use of this work by or on behalf */
8/* of the U.S. Government. Export of this program may require */
9/* a license from the United States Government. */
10/*--------------------------------------------------------------------*/
11
12#include <fei_fwd.hpp>
13#include <fei_defs.h>
14#include <fei_constants.hpp>
15#include "fei_TemplateUtils.hpp"
16#include <snl_fei_PointBlockMap.hpp>
17#include <fei_EqnBuffer.hpp>
18#include <fei_FieldDofMap.hpp>
19#include <fei_CSRMat.hpp>
20#include <fei_CSVec.hpp>
21
22#include <fei_NodeCommMgr.hpp>
23#include <fei_NodeDatabase.hpp>
24#include <fei_NodeDescriptor.hpp>
25
26#include <fei_Lookup.hpp>
27
43class SNL_FEI_Structure : public Lookup {
44 public:
53 SNL_FEI_Structure(MPI_Comm comm);
54
56 virtual ~SNL_FEI_Structure();
57
73 int parameters(int numParams, const char*const* paramStrings);
74
75 int initFields(int numFields, const int* fieldSizes, const int* fieldIDs,
76 const int* fieldTypes = NULL);
77
78 int initElemBlock(GlobalID elemBlockID,
79 int numElements,
80 int numNodesPerElement,
81 const int* numFieldsPerNode,
82 const int* const* nodalFieldIDs,
83 int numElemDofFieldsPerElement,
84 const int* elemDofFieldIDs,
85 int interleaveStrategy);
86
87 int initElem(GlobalID elemBlockID,
88 GlobalID elemID,
89 const GlobalID* elemConn);
90
91 int initSlaveVariable(GlobalID slaveNodeID,
92 int slaveFieldID,
93 int offsetIntoSlaveField,
94 int numMasterNodes,
95 const GlobalID* masterNodeIDs,
96 const int* masterFieldIDs,
97 const double* weights,
98 double rhsValue);
99
100 int deleteMultCRs();
101
102 int initSharedNodes(int numSharedNodes,
103 const GlobalID *sharedNodeIDs,
104 const int* numProcsPerNode,
105 const int *const *sharingProcIDs);
106
107 // constraint relation initialization
108 //- lagrange multiplier formulation
109 int initCRMult(int numCRNodes,
110 const GlobalID* CRNodes,
111 const int *CRFields,
112 int& CRID);
113
114 // - penalty function formulation
115 int initCRPen(int numCRNodes,
116 const GlobalID* CRNodes,
117 const int *CRFields,
118 int& CRID);
119
120 int initComplete(bool generateGraph = true);
121
122 const std::vector<int>& getFieldIDs() const
123 { return fieldIDs_; }
124
126 const int* getFieldIDsPtr()
127 {
128 int len = fieldDatabase_->size();
129 workarray_.resize(len*2);
130 fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
131 &workarray_[0],
132 &workarray_[0]+len);
133 return( &workarray_[0] );
134 }
135
137 const int* getFieldSizesPtr()
138 {
139 int len = fieldDatabase_->size();
140 workarray_.resize(len*2);
141 fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
142 &workarray_[0],
143 &workarray_[0]+len);
144 return( &workarray_[0]+len );
145 }
146
148 int getNumFields() { return( fieldDatabase_->size() ); };
149
151 int getFieldSize(int fieldID)
152 {
153 std::map<int,int>::const_iterator
154 f_iter = fieldDatabase_->find(fieldID);
155
156 return(f_iter != fieldDatabase_->end() ? (*f_iter).second : -1);
157 }
158
159 fei::FieldDofMap<int>& getFieldDofMap()
160 { return fieldDofMap_; }
161
163 bool isInLocalElement(int nodeNumber);
164
165 const int* getNumFieldsPerNode(GlobalID blockID);
166
167 const int* const* getFieldIDsTable(GlobalID blockID);
168
173 int getEqnNumber(int nodeNumber, int fieldID);
174
181 int getOwnerProcForEqn(int eqn);
182
183
185 //now the element-block functions
186
187 int getNumElemBlocks() {return(blockIDs_.size());};
188 const GlobalID* getElemBlockIDs() {return(&blockIDs_[0]);};
189
190 void getElemBlockInfo(GlobalID blockID,
191 int& interleaveStrategy, int& lumpingStrategy,
192 int& numElemDOF, int& numElements,
193 int& numNodesPerElem, int& numEqnsPerElem);
194
195 int addBlock(GlobalID blockID);
196
197 int getBlockDescriptor(GlobalID blockID, BlockDescriptor*& block);
198
202 int getBlockDescriptor_index(int index, BlockDescriptor*& block);
203
205 int getIndexOfBlock(GlobalID blockID) const;
207 int getBlockID(unsigned index) const
208 {
209 if (index < blockIDs_.size()) return blockIDs_[index];
210 return -1;
211 }
212
213 int allocateBlockConnectivity(GlobalID blockID);
214 void destroyConnectivityTables();
215
216 ConnectivityTable& getBlockConnectivity(GlobalID blockID);
217
218 void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
219 int interleaveStrategy,
220 int* scatterIndices);
221
222 void getScatterIndices_index(int blockIndex, int elemIndex,
223 int interleaveStrategy,
224 int* scatterIndices);
225
226 int getBlkScatterIndices_index(int blockIndex,
227 int elemIndex,
228 int* scatterIndices);
229
230 void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
231 int interleaveStrategy,
232 int* scatterIndices,
233 int* blkScatterIndices,
234 int* blkSizes);
235
236 void getScatterIndices_index(int blockIndex, int elemIndex,
237 int interleaveStrategy,
238 int* scatterIndices,
239 int* blkScatterIndices,
240 int* blkSizes);
241
242
244 //now the shared-node lookup functions from the Lookup interface.
245
246 int getNumSharedNodes() {return(nodeCommMgr_->getNumSharedNodes());};
247
248 const int* getSharedNodeNumbers() {
249 return(&(nodeCommMgr_->getSharedNodeNumbers())[0]);
250 };
251
252 const int* getSharedNodeProcs(int nodeNumber) {
253 int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
254 if (index < 0) return(NULL);
255 return(&(nodeCommMgr_->getSharedNodeProcs(index))[0]);
256 };
257
258 int getNumSharingProcs(int nodeNumber) {
259 int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
260 if (index < 0) return(-1);
261 return(nodeCommMgr_->getSharedNodeProcs(index).size());
262 };
263
264 int getNumSubdomains(int nodeNumber) {
265 const NodeDescriptor* node = NULL;
266 int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
267 if (err != 0) return(-1);
268 GlobalID nodeID = node->getGlobalNodeID();
269 return(nodeCommMgr_->getSharedNodeNumSubdomains(nodeID));
270 }
271
272 int* getSubdomainList(int nodeNumber) {
273 const NodeDescriptor* node = NULL;
274 int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
275 if (err != 0) return(NULL);
276 GlobalID nodeID = node->getGlobalNodeID();
277 return(&(*(nodeCommMgr_->getSharedNodeSubdomainList(nodeID)))[0]);
278
279 }
280
281 int translateToReducedNodeNumber(int nodeNumber, int proc);
282
284
286 int getAssociatedNodeNumber(int eqnNumber)
287 {
288 int eqn = translateFromReducedEqn(eqnNumber);
289 int nodeNumber = nodeDatabase_->getAssociatedNodeNumber(eqn);
290 int reducedNodeNumber = -1;
291 if (nodeNumber >= 0) {
292 reducedNodeNumber = translateToReducedNodeNumber(nodeNumber, localProc_);
293 }
294 return( reducedNodeNumber );
295 }
296
298 int getAssociatedFieldID(int eqnNumber)
299 {
300 int eqn = translateFromReducedEqn(eqnNumber);
301 return( nodeDatabase_->getAssociatedFieldID(eqn) );
302 }
303
304
306 //now the point-eqn to block-eqn queries...
307
308 bool isExactlyBlkEqn(int ptEqn) {
309 return(blkEqnMapper_->isExactlyBlkEqn(ptEqn));
310 };
311
312 int ptEqnToBlkEqn(int ptEqn) {
313 return(blkEqnMapper_->eqnToBlkEqn(ptEqn));
314 };
315
316 int getOffsetIntoBlkEqn(int blkEqn, int ptEqn) {
317 return(blkEqnMapper_->getBlkEqnOffset(blkEqn, ptEqn));
318 };
319
320 int getBlkEqnSize(int blkEqn) {
321 return(blkEqnMapper_->getBlkEqnSize(blkEqn));
322 }
324
325
326 int getNumActiveNodes() {return(nodeDatabase_->getNodeIDs().size());}
327
328 NodeDatabase& getNodeDatabase() { return( *nodeDatabase_ ); }
329
330 std::map<GlobalID,int>& getActiveNodeIDList()
331 { return( nodeDatabase_->getNodeIDs() ); }
332
333 std::vector<int>& getGlobalNodeOffsets() {return(globalNodeOffsets_);}
334 std::vector<int>& getGlobalEqnOffsets() {return(globalEqnOffsets_);}
335 std::vector<int>& getGlobalBlkEqnOffsets() {return(globalBlkEqnOffsets_);}
336
337 NodeCommMgr& getNodeCommMgr() {return(*nodeCommMgr_);}
338 EqnCommMgr& getEqnCommMgr() {return(*eqnCommMgr_ );}
339
340 void initializeEqnCommMgr();
341
342 void getEqnInfo(int& numGlobalEqns, int& numLocalEqns,
343 int& localStartRow, int& localEndRow);
344
345 int getEqnNumbers(GlobalID ID, int idType, int fieldID,
346 int& numEqns, int* eqnNumbers);
347
348 int getEqnNumbers(int numIDs, const GlobalID* IDs,
349 int idType, int fieldID,
350 int& numEqns, int* eqnNumbers);
351
352 void getEqnBlkInfo(int& numGlobalEqnBlks, int& numLocalEqnBlks,
353 int& localBlkOffset);
354
355 snl_fei::PointBlockMap& getBlkEqnMapper() {return(*blkEqnMapper_);}
356
357 void destroyMatIndices();
358
359 int getNumMultConstRecords() {return(multCRs_.size());};
360
361 std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
362 getMultConstRecords()
363 {return(multCRs_);};
364
365 int getMultConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& multCR)
366 {
367 std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
368 cr_iter = multCRs_.find(CRID);
369 int returncode = -1;
370 if (cr_iter != multCRs_.end()) {
371 multCR = (*cr_iter).second;
372 returncode = 0;
373 }
374
375 return( returncode );
376 }
377
378 int getNumPenConstRecords() {return(penCRs_.size());}
379 std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
380 getPenConstRecords()
381 { return(penCRs_); }
382
383 int getPenConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& penCR)
384 {
385 std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
386 cr_iter = penCRs_.find(CRID);
387 int returncode = -1;
388 if (cr_iter != penCRs_.end()) {
389 penCR = (*cr_iter).second;
390 returncode = 0;
391 }
392
393 return( returncode );
394 }
395
396 void addSlaveVariable(SlaveVariable* svar) {slaveVars_->push_back(svar);}
397
398 int calculateSlaveEqns(MPI_Comm comm);
399
400 fei::FillableMat* getSlaveDependencies() {return(slaveMatrix_);}
401
402 EqnBuffer* getSlaveEqns() { return(slaveEqns_); }
403
404 int numSlaveEquations() { return(numSlvs_); }
405
408 bool isSlaveEqn(int eqn);
409
418 bool translateToReducedEqn(int eqn, int& reducedEqn);
419
424 int translateToReducedEqns(EqnCommMgr& eqnCommMgr);
425
431
436 int translateToReducedEqns(ProcEqns& procEqns);
437
443
449 int translateFromReducedEqn(int reducedEqn);
450
457 int getMasterEqnNumbers(int slaveEqn, std::vector<int>*& masterEqns);
458
465 int getMasterEqnCoefs(int slaveEqn, std::vector<double>*& masterCoefs);
466
474 int getMasterEqnRHS(int slaveEqn, double& rhsValue);
475
476 int getNumGlobalEqns() { return( numGlobalEqns_ ); }
477 int getNumLocalEqns() { return( numLocalEqns_ ); }
478 int getFirstLocalEqn() { return( localStartRow_ ); }
479 int getLastLocalEqn() { return( localEndRow_ ); }
480
481 int getFirstReducedEqn() { return( reducedStartRow_ ); }
482 int getLastReducedEqn() { return( reducedEndRow_ ); }
483
484 int getNumGlobalEqnBlks() { return( numGlobalEqnBlks_ ); }
485 int getNumLocalEqnBlks() { return( numLocalEqnBlks_ ); }
486 int getNumLocalReducedEqnBlks() { return( numLocalReducedEqnBlks_ ); }
487 int getGlobalMaxBlkSize() { return(globalMaxBlkSize_); }
488
489 int getNumLocalReducedEqns() { return( numLocalReducedRows_ ); }
490
491 int getMatrixRowLengths(std::vector<int>& rowLengths);
492 int getMatrixStructure(int** colIndices, std::vector<int>& rowLengths);
493
494 int getMatrixStructure(int** ptColIndices, std::vector<int>& ptRowLengths,
495 int** blkColIndices, int* blkIndices_1D,
496 std::vector<int>& blkRowLengths,
497 std::vector<int>& numPtRowsPerBlkRow);
498
499 static int gatherSlaveEqns(MPI_Comm comm,
500 EqnCommMgr* eqnCommMgr,
501 EqnBuffer* slaveEqns);
502
503 static int removeCouplings(EqnBuffer& eqnbuf, int& levelsOfCoupling);
504
505 int calcTotalNumElemDOF();
506 int calcNumMultCREqns();
507
508 MPI_Comm getCommunicator() const { return( comm_ ); }
509
510#ifdef FEI_HAVE_IOSFWD
511 int setDbgOut(std::ostream& ostr, const char* path, const char* feiName);
512#else
513 int setDbgOut(ostream& ostr, const char* path, const char* feiName);
514#endif
515
516 private:
517
521 NodeDescriptor* findNode(GlobalID nodeID);
525 NodeDescriptor& findNodeDescriptor(GlobalID nodeID);
526
527 int writeEqn2NodeMap();
528
529 int getElemNodeDescriptors(int blockIndex, int elemIndex,
530 NodeDescriptor** nodes);
531
532 int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
533 int fieldID,
534 int* scatterIndices, int& offset);
535
536 int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
537 int fieldID,
538 int* scatterIndices, int& offset,
539 int* blkScatterIndices,
540 int* blkSizes, int& blkOffset);
541
542 int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
543 int** fieldIDs, int* fieldsPerNode,
544 int* scatterIndices, int& offset);
545
546 int getNodeBlkIndices(NodeDescriptor** nodes, int numNodes,
547 int* scatterIndices, int& offset);
548
549 int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
550 int** fieldIDs, int* fieldsPerNode,
551 int* scatterIndices, int& offset,
552 int* blkScatterIndices,
553 int* blkSizes, int& blkOffset);
554
555 int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
556 std::vector<int>* fieldIDs,
557 std::vector<int>& fieldsPerNode,
558 std::vector<int>& scatterIndices);
559
560 int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
561 int** fieldIDs, int* fieldsPerNode,
562 int* scatterIndices, int& offset);
563
564 int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
565 std::vector<int>* fieldIDs,
566 std::vector<int>& fieldsPerNode,
567 std::vector<int>& scatterIndices);
568
569 void calcGlobalEqnInfo(int numLocallyOwnedNodes,
570 int numLocalEqns,
571 int numLocalEqnBlks);
572
573 int finalizeActiveNodes();
574 int finalizeNodeCommMgr();
575 bool activeNodesInitialized();
576
577 int formMatrixStructure();
578
579 int initElemBlockStructure();
580 int initMultCRStructure();
581 int initPenCRStructure();
582 int createMatrixPosition(int row, int col, const char* callingFunction);
583 int createMatrixPositions(int row, int numCols, int* cols,
584 const char* callingFunction);
585 int createMatrixPositions(fei::CSRMat& mat);
586
587 int createSymmEqnStructure(std::vector<int>& scatterIndices);
588 int createBlkSymmEqnStructure(std::vector<int>& scatterIndices);
589
590 int storeElementScatterIndices(std::vector<int>& scatterIndices);
591 int storeElementScatterIndices_noSlaves(std::vector<int>& scatterIndices);
592 int storeElementScatterBlkIndices_noSlaves(std::vector<int>& scatterIndices);
593
594 void storeLocalNodeIndices(NodeDescriptor& iNode, int iField,
595 NodeDescriptor& jNode, int jField);
596 void storeNodalColumnIndices(int eqn, NodeDescriptor& node,
597 int fieldID);
598 void storeNodalRowIndices(NodeDescriptor& node, int fieldID, int eqn);
599 void storeNodalSendIndex(NodeDescriptor& node, int fieldID, int col);
600 void storeNodalSendIndices(NodeDescriptor& iNode, int iField,
601 NodeDescriptor& jNode, int jField);
602
603 int assembleReducedStructure();
604
605 bool nodalEqnsAllSlaves(const NodeDescriptor* node, std::vector<int>& slaveEqns);
606
607 int initializeBlkEqnMapper();
608
609 int setNumNodesAndEqnsPerBlock();
610
611 void destroyBlockRoster();
612
613#ifdef FEI_HAVE_IOSFWD
614 std::ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
615#else
616 ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
617#endif
618
619 void addCR(int CRID,
621 std::map<GlobalID,snl_fei::Constraint<GlobalID>* >& crDB);
622
623 int setNodalEqnInfo();
624 void setElemDOFEqnInfo();
625 int setMultCREqnInfo();
626
628 SNL_FEI_Structure& operator=(const SNL_FEI_Structure& src);
629
630 MPI_Comm comm_;
631
632 int localProc_, masterProc_, numProcs_;
633
634 std::vector<int> fieldIDs_;
635 std::vector<int> fieldSizes_;
636 std::map<int,int>* fieldDatabase_;
637 fei::FieldDofMap<int> fieldDofMap_;
638 std::vector<int> workarray_;
639
640 std::vector<GlobalID> blockIDs_;
641 std::vector<BlockDescriptor*> blocks_;
642 std::vector<ConnectivityTable*> connTables_;
643
644 NodeDatabase* nodeDatabase_;
645
646 bool activeNodesInitialized_;
647
648 std::vector<int> globalNodeOffsets_;
649 std::vector<int> globalEqnOffsets_;
650 std::vector<int> globalBlkEqnOffsets_;
651
652 std::vector<SlaveVariable*>* slaveVars_;
653 EqnBuffer* slaveEqns_;
654 std::vector<int>* slvEqnNumbers_;
655 int numSlvs_, lowestSlv_, highestSlv_;
656 fei::FillableMat* slaveMatrix_;
657 std::vector<int> globalNumNodesVanished_;
658 std::vector<int> localVanishedNodeNumbers_;
659
660 NodeCommMgr* nodeCommMgr_;
661 EqnCommMgr* eqnCommMgr_;
662 EqnCommMgr* slvCommMgr_;
663
664 int numGlobalEqns_;
665 int numLocalEqns_;
666 int localStartRow_;
667 int localEndRow_;
668
669 int numLocalNodalEqns_;
670 int numLocalElemDOF_;
671 int numLocalMultCRs_;
672
673 int reducedStartRow_, reducedEndRow_, numLocalReducedRows_;
674 fei::FillableMat *Kid_, *Kdi_, *Kdd_;
675 fei::CSRMat csrD, csrKid, csrKdi, csrKdd, tmpMat1_, tmpMat2_;
676 int reducedEqnCounter_, reducedRHSCounter_;
677 std::vector<int> rSlave_, cSlave_;
678 std::vector<NodeDescriptor*> work_nodePtrs_;
679
680 bool structureFinalized_;
681 bool generateGraph_;
682
683 fei::ctg_set<int>* sysMatIndices_;
684
685 bool blockMatrix_;
686 int numGlobalEqnBlks_;
687 int numLocalEqnBlks_;
688 int numLocalReducedEqnBlks_;
689 int localBlkOffset_;
690 int localReducedBlkOffset_;
691 int globalMaxBlkSize_;
692
693 int firstLocalNodeNumber_;
694 int numGlobalNodes_;
695
696 fei::ctg_set<int>* sysBlkMatIndices_;
697 bool matIndicesDestroyed_;
698
699 std::vector<int> workSpace_;
700
701 snl_fei::PointBlockMap* blkEqnMapper_;
702
703 std::map<GlobalID, snl_fei::Constraint<GlobalID>* > multCRs_;
704
705 std::map<GlobalID, snl_fei::Constraint<GlobalID>* > penCRs_;
706
707 bool checkSharedNodes_;
708
709 std::string name_;
710
711 int outputLevel_;
712 bool debugOutput_;
713 std::string dbgPath_;
714#ifdef FEI_HAVE_IOSFWD
715 std::ostream* dbgOStreamPtr_;
716#else
717 ostream* dbgOStreamPtr_;
718#endif
719 bool setDbgOutCalled_;
720};
721
722#endif
723
int getNodeWithNumber(int nodeNumber, const NodeDescriptor *&node) const
int getAssociatedNodeNumber(int eqnNumber)
std::map< GlobalID, int > & getNodeIDs()
int getAssociatedFieldID(int eqnNumber)
int translateMatToReducedEqns(fei::CSRMat &mat)
int getOffsetIntoBlkEqn(int blkEqn, int ptEqn)
int getMasterEqnRHS(int slaveEqn, double &rhsValue)
int parameters(int numParams, const char *const *paramStrings)
int translateToReducedEqns(EqnCommMgr &eqnCommMgr)
const GlobalID * getElemBlockIDs()
int getAssociatedNodeNumber(int eqnNumber)
int getFieldSize(int fieldID)
int getBlockDescriptor_index(int index, BlockDescriptor *&block)
const int * getSharedNodeProcs(int nodeNumber)
const int *const * getFieldIDsTable(GlobalID blockID)
int getNumSharingProcs(int nodeNumber)
int getNumSubdomains(int nodeNumber)
int getBlkEqnSize(int blkEqn)
int getAssociatedFieldID(int eqnNumber)
void getElemBlockInfo(GlobalID blockID, int &interleaveStrategy, int &lumpingStrategy, int &numElemDOF, int &numElements, int &numNodesPerElem, int &numEqnsPerElem)
int translateFromReducedEqn(int reducedEqn)
int ptEqnToBlkEqn(int ptEqn)
int getEqnNumber(int nodeNumber, int fieldID)
int getMasterEqnCoefs(int slaveEqn, std::vector< double > *&masterCoefs)
const int * getFieldIDsPtr()
bool isExactlyBlkEqn(int ptEqn)
int getIndexOfBlock(GlobalID blockID) const
SNL_FEI_Structure(MPI_Comm comm)
int getMasterEqnNumbers(int slaveEqn, std::vector< int > *&masterEqns)
const int * getNumFieldsPerNode(GlobalID blockID)
bool isInLocalElement(int nodeNumber)
int getBlockID(unsigned index) const
const int * getFieldSizesPtr()
int * getSubdomainList(int nodeNumber)
const int * getSharedNodeNumbers()
int getOwnerProcForEqn(int eqn)
bool translateToReducedEqn(int eqn, int &reducedEqn)
int getBlkEqnOffset(int blkEqn, int ptEqn)