FEI Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
SNL_FEI_Structure.hpp
Go to the documentation of this file.
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"
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>
25
26#include <fei_Lookup.hpp>
27
43class SNL_FEI_Structure : public Lookup {
44 public:
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
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
215
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
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();
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
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
339
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
356
357 void destroyMatIndices();
358
359 int getNumMultConstRecords() {return(multCRs_.size());};
360
361 std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
363 {return(multCRs_);};
364
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>*>&
381 { return(penCRs_); }
382
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
399
401
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
483
488
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
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
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
576
578
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);
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
604
605 bool nodalEqnsAllSlaves(const NodeDescriptor* node, std::vector<int>& slaveEqns);
606
608
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
629
631
633
634 std::vector<int> fieldIDs_;
635 std::vector<int> fieldSizes_;
636 std::map<int,int>* fieldDatabase_;
638 std::vector<int> workarray_;
639
640 std::vector<GlobalID> blockIDs_;
641 std::vector<BlockDescriptor*> blocks_;
642 std::vector<ConnectivityTable*> connTables_;
643
645
647
648 std::vector<int> globalNodeOffsets_;
649 std::vector<int> globalEqnOffsets_;
650 std::vector<int> globalBlkEqnOffsets_;
651
652 std::vector<SlaveVariable*>* slaveVars_;
654 std::vector<int>* slvEqnNumbers_;
657 std::vector<int> globalNumNodesVanished_;
659
663
668
672
677 std::vector<int> rSlave_, cSlave_;
678 std::vector<NodeDescriptor*> work_nodePtrs_;
679
682
684
692
695
698
699 std::vector<int> workSpace_;
700
702
703 std::map<GlobalID, snl_fei::Constraint<GlobalID>* > multCRs_;
704
705 std::map<GlobalID, snl_fei::Constraint<GlobalID>* > penCRs_;
706
708
709 std::string name_;
710
713 std::string dbgPath_;
714#ifdef FEI_HAVE_IOSFWD
715 std::ostream* dbgOStreamPtr_;
716#else
718#endif
720};
721
722#endif
723
std::vector< int > & getSharedNodeNumbers()
int getSharedNodeIndex_num(int nodeNumber)
std::vector< int > & getSharedNodeProcs(int index)
int getSharedNodeNumSubdomains(GlobalID nodeID)
std::vector< int > * getSharedNodeSubdomainList(GlobalID nodeID)
size_t getNumSharedNodes()
int getNodeWithNumber(int nodeNumber, const NodeDescriptor *&node) const
int getAssociatedNodeNumber(int eqnNumber)
std::map< GlobalID, int > & getNodeIDs()
int getAssociatedFieldID(int eqnNumber)
GlobalID getGlobalNodeID() const
std::vector< int > fieldSizes_
int translateMatToReducedEqns(fei::CSRMat &mat)
fei::FieldDofMap< int > fieldDofMap_
static int gatherSlaveEqns(MPI_Comm comm, EqnCommMgr *eqnCommMgr, EqnBuffer *slaveEqns)
int initFields(int numFields, const int *fieldSizes, const int *fieldIDs, const int *fieldTypes=NULL)
EqnBuffer * getSlaveEqns()
int getOffsetIntoBlkEqn(int blkEqn, int ptEqn)
snl_fei::PointBlockMap * blkEqnMapper_
std::vector< NodeDescriptor * > work_nodePtrs_
int initSlaveVariable(GlobalID slaveNodeID, int slaveFieldID, int offsetIntoSlaveField, int numMasterNodes, const GlobalID *masterNodeIDs, const int *masterFieldIDs, const double *weights, double rhsValue)
void getEqnInfo(int &numGlobalEqns, int &numLocalEqns, int &localStartRow, int &localEndRow)
int getMasterEqnRHS(int slaveEqn, double &rhsValue)
int storeElementScatterIndices(std::vector< int > &scatterIndices)
std::vector< int > & getGlobalEqnOffsets()
fei::FillableMat * Kid_
int getElemNodeDescriptors(int blockIndex, int elemIndex, NodeDescriptor **nodes)
std::map< GlobalID, snl_fei::Constraint< GlobalID > * > multCRs_
std::vector< int > rSlave_
std::vector< int > workarray_
bool activeNodesInitialized()
SNL_FEI_Structure & operator=(const SNL_FEI_Structure &src)
int translateToReducedEqns(EqnCommMgr &eqnCommMgr)
std::vector< int > & getGlobalNodeOffsets()
int getEqnNumbers(GlobalID ID, int idType, int fieldID, int &numEqns, int *eqnNumbers)
void storeNodalRowIndices(NodeDescriptor &node, int fieldID, int eqn)
const GlobalID * getElemBlockIDs()
NodeDatabase & getNodeDatabase()
int initComplete(bool generateGraph=true)
int getAssociatedNodeNumber(int eqnNumber)
std::map< int, int > * fieldDatabase_
int createSymmEqnStructure(std::vector< int > &scatterIndices)
fei::FieldDofMap< int > & getFieldDofMap()
int getFieldSize(int fieldID)
fei::FillableMat * Kdd_
void getScatterIndices_ID(GlobalID blockID, GlobalID elemID, int interleaveStrategy, int *scatterIndices)
int allocateBlockConnectivity(GlobalID blockID)
int initCRMult(int numCRNodes, const GlobalID *CRNodes, const int *CRFields, int &CRID)
std::vector< SlaveVariable * > * slaveVars_
void storeNodalSendIndices(NodeDescriptor &iNode, int iField, NodeDescriptor &jNode, int jField)
int getBlockDescriptor_index(int index, BlockDescriptor *&block)
const int * getSharedNodeProcs(int nodeNumber)
std::vector< BlockDescriptor * > blocks_
std::map< GlobalID, int > & getActiveNodeIDList()
std::vector< int > globalNumNodesVanished_
const int *const * getFieldIDsTable(GlobalID blockID)
int calculateSlaveEqns(MPI_Comm comm)
int getNumSharingProcs(int nodeNumber)
int getNumSubdomains(int nodeNumber)
std::map< GlobalID, snl_fei::Constraint< GlobalID > * > & getPenConstRecords()
void calcGlobalEqnInfo(int numLocallyOwnedNodes, int numLocalEqns, int numLocalEqnBlks)
int getMatrixRowLengths(std::vector< int > &rowLengths)
int getMatrixStructure(int **colIndices, std::vector< int > &rowLengths)
int getBlkEqnSize(int blkEqn)
int getBlockDescriptor(GlobalID blockID, BlockDescriptor *&block)
std::vector< int > globalBlkEqnOffsets_
int storeElementScatterIndices_noSlaves(std::vector< int > &scatterIndices)
int getAssociatedFieldID(int eqnNumber)
fei::FillableMat * getSlaveDependencies()
void getElemBlockInfo(GlobalID blockID, int &interleaveStrategy, int &lumpingStrategy, int &numElemDOF, int &numElements, int &numNodesPerElem, int &numEqnsPerElem)
int getPenConstRecord(int CRID, snl_fei::Constraint< GlobalID > *&penCR)
int translateFromReducedEqn(int reducedEqn)
SNL_FEI_Structure(const SNL_FEI_Structure &src)
int translateToReducedNodeNumber(int nodeNumber, int proc)
std::map< GlobalID, snl_fei::Constraint< GlobalID > * > & getMultConstRecords()
int getBlkScatterIndices_index(int blockIndex, int elemIndex, int *scatterIndices)
void addSlaveVariable(SlaveVariable *svar)
int initSharedNodes(int numSharedNodes, const GlobalID *sharedNodeIDs, const int *numProcsPerNode, const int *const *sharingProcIDs)
int ptEqnToBlkEqn(int ptEqn)
NodeDescriptor & findNodeDescriptor(GlobalID nodeID)
fei::FillableMat * slaveMatrix_
int setDbgOut(ostream &ostr, const char *path, const char *feiName)
static int removeCouplings(EqnBuffer &eqnbuf, int &levelsOfCoupling)
MPI_Comm getCommunicator() const
int getEqnNumber(int nodeNumber, int fieldID)
int getMasterEqnCoefs(int slaveEqn, std::vector< double > *&masterCoefs)
const int * getFieldIDsPtr()
int createBlkSymmEqnStructure(std::vector< int > &scatterIndices)
void storeNodalColumnIndices(int eqn, NodeDescriptor &node, int fieldID)
fei::ctg_set< int > * sysMatIndices_
int initCRPen(int numCRNodes, const GlobalID *CRNodes, const int *CRFields, int &CRID)
std::map< GlobalID, snl_fei::Constraint< GlobalID > * > penCRs_
void storeNodalSendIndex(NodeDescriptor &node, int fieldID, int col)
int createMatrixPositions(int row, int numCols, int *cols, const char *callingFunction)
void getEqnBlkInfo(int &numGlobalEqnBlks, int &numLocalEqnBlks, int &localBlkOffset)
bool isExactlyBlkEqn(int ptEqn)
int getFieldMajorIndices(NodeDescriptor **nodes, int numNodes, int **fieldIDs, int *fieldsPerNode, int *scatterIndices, int &offset)
int getNodeIndices_simple(NodeDescriptor **nodes, int numNodes, int fieldID, int *scatterIndices, int &offset)
int getIndexOfBlock(GlobalID blockID) const
std::vector< GlobalID > blockIDs_
NodeDatabase * nodeDatabase_
snl_fei::PointBlockMap & getBlkEqnMapper()
std::vector< int > globalEqnOffsets_
std::vector< int > globalNodeOffsets_
int getNodeBlkIndices(NodeDescriptor **nodes, int numNodes, int *scatterIndices, int &offset)
int createMatrixPosition(int row, int col, const char *callingFunction)
int getMasterEqnNumbers(int slaveEqn, std::vector< int > *&masterEqns)
int initElemBlock(GlobalID elemBlockID, int numElements, int numNodesPerElement, const int *numFieldsPerNode, const int *const *nodalFieldIDs, int numElemDofFieldsPerElement, const int *elemDofFieldIDs, int interleaveStrategy)
const int * getNumFieldsPerNode(GlobalID blockID)
NodeCommMgr * nodeCommMgr_
void storeLocalNodeIndices(NodeDescriptor &iNode, int iField, NodeDescriptor &jNode, int jField)
std::vector< int > cSlave_
fei::FillableMat * Kdi_
const std::vector< int > & getFieldIDs() const
bool isInLocalElement(int nodeNumber)
void addCR(int CRID, snl_fei::Constraint< GlobalID > *&cr, std::map< GlobalID, snl_fei::Constraint< GlobalID > * > &crDB)
int getBlockID(unsigned index) const
bool nodalEqnsAllSlaves(const NodeDescriptor *node, std::vector< int > &slaveEqns)
const int * getFieldSizesPtr()
int getMultConstRecord(int CRID, snl_fei::Constraint< GlobalID > *&multCR)
NodeCommMgr & getNodeCommMgr()
ConnectivityTable & getBlockConnectivity(GlobalID blockID)
int * getSubdomainList(int nodeNumber)
std::vector< int > localVanishedNodeNumbers_
std::vector< int > workSpace_
std::vector< int > fieldIDs_
EqnCommMgr & getEqnCommMgr()
const int * getSharedNodeNumbers()
std::vector< int > & getGlobalBlkEqnOffsets()
std::vector< ConnectivityTable * > connTables_
NodeDescriptor * findNode(GlobalID nodeID)
int getOwnerProcForEqn(int eqn)
int storeElementScatterBlkIndices_noSlaves(std::vector< int > &scatterIndices)
bool translateToReducedEqn(int eqn, int &reducedEqn)
fei::ctg_set< int > * sysBlkMatIndices_
void getScatterIndices_index(int blockIndex, int elemIndex, int interleaveStrategy, int *scatterIndices)
int addBlock(GlobalID blockID)
std::vector< int > * slvEqnNumbers_
int getNodeMajorIndices(NodeDescriptor **nodes, int numNodes, int **fieldIDs, int *fieldsPerNode, int *scatterIndices, int &offset)
int getBlkEqnOffset(int blkEqn, int ptEqn)
int GlobalID
Definition: fei_defs.h:60
#define MPI_Comm
Definition: fei_mpi.h:56