FEI Version of the Day
SNL_FEI_Structure.hpp
00001 /*
00002 // @HEADER
00003 // ************************************************************************
00004 //             FEI: Finite Element Interface to Linear Solvers
00005 //                  Copyright (2005) Sandia Corporation.
00006 //
00007 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the
00008 // U.S. Government retains certain rights in this software.
00009 //
00010 // Redistribution and use in source and binary forms, with or without
00011 // modification, are permitted provided that the following conditions are
00012 // met:
00013 //
00014 // 1. Redistributions of source code must retain the above copyright
00015 // notice, this list of conditions and the following disclaimer.
00016 //
00017 // 2. Redistributions in binary form must reproduce the above copyright
00018 // notice, this list of conditions and the following disclaimer in the
00019 // documentation and/or other materials provided with the distribution.
00020 //
00021 // 3. Neither the name of the Corporation nor the names of the
00022 // contributors may be used to endorse or promote products derived from
00023 // this software without specific prior written permission.
00024 //
00025 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
00026 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00027 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00028 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
00029 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00030 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00031 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00032 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00033 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00034 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00035 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00036 //
00037 // Questions? Contact Alan Williams (william@sandia.gov) 
00038 //
00039 // ************************************************************************
00040 // @HEADER
00041 */
00042 
00043 #ifndef _SNL_FEI_Structure_hpp_
00044 #define _SNL_FEI_Structure_hpp_
00045 
00046 
00047 #include <fei_fwd.hpp>
00048 #include <fei_defs.h>
00049 #include <fei_constants.hpp>
00050 #include "fei_TemplateUtils.hpp"
00051 #include <snl_fei_PointBlockMap.hpp>
00052 #include <fei_EqnBuffer.hpp>
00053 #include <fei_FieldDofMap.hpp>
00054 #include <fei_CSRMat.hpp>
00055 #include <fei_CSVec.hpp>
00056 
00057 #include <fei_NodeCommMgr.hpp>
00058 #include <fei_NodeDatabase.hpp>
00059 #include <fei_NodeDescriptor.hpp>
00060 
00061 #include <fei_Lookup.hpp>
00062 
00078 class SNL_FEI_Structure : public Lookup {
00079  public:
00088    SNL_FEI_Structure(MPI_Comm comm);
00089 
00091    virtual ~SNL_FEI_Structure();
00092 
00108    int parameters(int numParams, const char*const* paramStrings);
00109 
00110    int initFields(int numFields, const int* fieldSizes, const int* fieldIDs,
00111                   const int* fieldTypes = NULL);
00112 
00113    int initElemBlock(GlobalID elemBlockID,
00114          int numElements,
00115          int numNodesPerElement,
00116          const int* numFieldsPerNode,
00117          const int* const* nodalFieldIDs,
00118          int numElemDofFieldsPerElement,
00119          const int* elemDofFieldIDs,
00120          int interleaveStrategy);
00121 
00122    int initElem(GlobalID elemBlockID,
00123     GlobalID elemID,
00124     const GlobalID* elemConn);
00125 
00126    int initSlaveVariable(GlobalID slaveNodeID, 
00127        int slaveFieldID,
00128        int offsetIntoSlaveField,
00129        int numMasterNodes,
00130        const GlobalID* masterNodeIDs,
00131        const int* masterFieldIDs,
00132        const double* weights,
00133        double rhsValue);
00134 
00135    int deleteMultCRs();
00136 
00137    int initSharedNodes(int numSharedNodes,
00138            const GlobalID *sharedNodeIDs,  
00139            const int* numProcsPerNode, 
00140            const int *const *sharingProcIDs);
00141 
00142    // constraint relation initialization
00143    //- lagrange multiplier formulation
00144    int initCRMult(int numCRNodes,
00145       const GlobalID* CRNodes,
00146       const int *CRFields,
00147       int& CRID);
00148 
00149    // - penalty function formulation
00150    int initCRPen(int numCRNodes,
00151      const GlobalID* CRNodes, 
00152      const int *CRFields,
00153      int& CRID); 
00154 
00155    int initComplete(bool generateGraph = true);
00156 
00157    const std::vector<int>& getFieldIDs() const
00158      { return fieldIDs_; }
00159 
00161    const int* getFieldIDsPtr()
00162      {
00163        int len = fieldDatabase_->size();
00164        workarray_.resize(len*2);
00165        fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
00166              &workarray_[0],
00167              &workarray_[0]+len);
00168        return( &workarray_[0] );
00169      }
00170 
00172    const int* getFieldSizesPtr()
00173      {
00174        int len = fieldDatabase_->size();
00175        workarray_.resize(len*2);
00176        fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
00177              &workarray_[0],
00178              &workarray_[0]+len);
00179        return( &workarray_[0]+len );
00180      }
00181 
00183    int getNumFields() { return( fieldDatabase_->size() ); };
00184 
00186    int getFieldSize(int fieldID)
00187      {
00188        std::map<int,int>::const_iterator
00189    f_iter = fieldDatabase_->find(fieldID);
00190 
00191        return(f_iter != fieldDatabase_->end() ? (*f_iter).second : -1);
00192      }
00193 
00194    fei::FieldDofMap<int>& getFieldDofMap()
00195      { return fieldDofMap_; }
00196 
00198    bool isInLocalElement(int nodeNumber);
00199 
00200    const int* getNumFieldsPerNode(GlobalID blockID);
00201 
00202    const int* const* getFieldIDsTable(GlobalID blockID);
00203 
00208    int getEqnNumber(int nodeNumber, int fieldID);
00209 
00216    int getOwnerProcForEqn(int eqn);
00217 
00218 
00220    //now the element-block functions
00221 
00222    int getNumElemBlocks() {return(blockIDs_.size());};
00223    const GlobalID* getElemBlockIDs() {return(&blockIDs_[0]);};
00224 
00225    void getElemBlockInfo(GlobalID blockID,
00226                          int& interleaveStrategy, int& lumpingStrategy,
00227                          int& numElemDOF, int& numElements,
00228                          int& numNodesPerElem, int& numEqnsPerElem);
00229 
00230    int addBlock(GlobalID blockID);
00231 
00232    int getBlockDescriptor(GlobalID blockID, BlockDescriptor*& block);
00233 
00237    int getBlockDescriptor_index(int index, BlockDescriptor*& block);
00238 
00240    int getIndexOfBlock(GlobalID blockID) const;
00242    int getBlockID(unsigned index) const
00243    {
00244      if (index < blockIDs_.size()) return blockIDs_[index];
00245      return -1;
00246    }
00247 
00248    int allocateBlockConnectivity(GlobalID blockID);
00249    void destroyConnectivityTables();
00250 
00251    ConnectivityTable& getBlockConnectivity(GlobalID blockID);
00252 
00253    void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
00254                              int interleaveStrategy,
00255                              int* scatterIndices);
00256 
00257    void getScatterIndices_index(int blockIndex, int elemIndex,
00258                              int interleaveStrategy,
00259                              int* scatterIndices);
00260 
00261    int getBlkScatterIndices_index(int blockIndex,
00262           int elemIndex,
00263           int* scatterIndices);
00264 
00265    void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
00266                              int interleaveStrategy,
00267                              int* scatterIndices,
00268            int* blkScatterIndices,
00269            int* blkSizes);
00270 
00271    void getScatterIndices_index(int blockIndex, int elemIndex,
00272                              int interleaveStrategy,
00273                              int* scatterIndices,
00274            int* blkScatterIndices,
00275         int* blkSizes);
00276 
00277 
00279    //now the shared-node lookup functions from the Lookup interface.
00280 
00281    int getNumSharedNodes() {return(nodeCommMgr_->getNumSharedNodes());};
00282 
00283    const int* getSharedNodeNumbers() {
00284       return(&(nodeCommMgr_->getSharedNodeNumbers())[0]);
00285    };
00286 
00287    const int* getSharedNodeProcs(int nodeNumber) {
00288       int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
00289       if (index < 0) return(NULL);
00290       return(&(nodeCommMgr_->getSharedNodeProcs(index))[0]);
00291    };
00292 
00293    int getNumSharingProcs(int nodeNumber) {
00294       int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
00295       if (index < 0) return(-1);
00296       return(nodeCommMgr_->getSharedNodeProcs(index).size());
00297    };
00298 
00299    int getNumSubdomains(int nodeNumber) {
00300      const NodeDescriptor* node = NULL;
00301      int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
00302      if (err != 0) return(-1);
00303      GlobalID nodeID = node->getGlobalNodeID();
00304      return(nodeCommMgr_->getSharedNodeNumSubdomains(nodeID));
00305    }
00306 
00307    int* getSubdomainList(int nodeNumber) {
00308      const NodeDescriptor* node = NULL;
00309      int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
00310      if (err != 0) return(NULL);
00311      GlobalID nodeID = node->getGlobalNodeID();
00312      return(&(*(nodeCommMgr_->getSharedNodeSubdomainList(nodeID)))[0]);
00313 
00314    }
00315 
00316    int translateToReducedNodeNumber(int nodeNumber, int proc);
00317 
00319 
00321    int getAssociatedNodeNumber(int eqnNumber)
00322      {
00323        int eqn = translateFromReducedEqn(eqnNumber);
00324        int nodeNumber = nodeDatabase_->getAssociatedNodeNumber(eqn);
00325        int reducedNodeNumber = -1;
00326        if (nodeNumber >= 0) {
00327    reducedNodeNumber = translateToReducedNodeNumber(nodeNumber, localProc_);
00328        }
00329        return( reducedNodeNumber );
00330      }
00331 
00333    int getAssociatedFieldID(int eqnNumber)
00334      {
00335        int eqn = translateFromReducedEqn(eqnNumber);
00336        return( nodeDatabase_->getAssociatedFieldID(eqn) );
00337      }
00338 
00339 
00341    //now the point-eqn to block-eqn queries...
00342 
00343    bool isExactlyBlkEqn(int ptEqn) {
00344       return(blkEqnMapper_->isExactlyBlkEqn(ptEqn));
00345    };
00346 
00347    int ptEqnToBlkEqn(int ptEqn) {
00348       return(blkEqnMapper_->eqnToBlkEqn(ptEqn));
00349    };
00350  
00351    int getOffsetIntoBlkEqn(int blkEqn, int ptEqn) {
00352       return(blkEqnMapper_->getBlkEqnOffset(blkEqn, ptEqn));
00353    };
00354 
00355    int getBlkEqnSize(int blkEqn) {
00356       return(blkEqnMapper_->getBlkEqnSize(blkEqn));
00357    }
00359 
00360 
00361    int getNumActiveNodes() {return(nodeDatabase_->getNodeIDs().size());}
00362 
00363    NodeDatabase& getNodeDatabase() { return( *nodeDatabase_ ); }
00364 
00365    std::map<GlobalID,int>& getActiveNodeIDList()
00366      { return( nodeDatabase_->getNodeIDs() ); }
00367 
00368    std::vector<int>& getGlobalNodeOffsets() {return(globalNodeOffsets_);}
00369    std::vector<int>& getGlobalEqnOffsets() {return(globalEqnOffsets_);}
00370    std::vector<int>& getGlobalBlkEqnOffsets() {return(globalBlkEqnOffsets_);}
00371 
00372    NodeCommMgr& getNodeCommMgr() {return(*nodeCommMgr_);}
00373    EqnCommMgr&  getEqnCommMgr()  {return(*eqnCommMgr_ );}
00374 
00375    void initializeEqnCommMgr();
00376 
00377    void getEqnInfo(int& numGlobalEqns, int& numLocalEqns,
00378                    int& localStartRow, int& localEndRow);
00379 
00380    int getEqnNumbers(GlobalID ID, int idType, int fieldID,
00381          int& numEqns, int* eqnNumbers);
00382 
00383    int getEqnNumbers(int numIDs, const GlobalID* IDs,
00384          int idType, int fieldID,
00385          int& numEqns, int* eqnNumbers);
00386 
00387    void getEqnBlkInfo(int& numGlobalEqnBlks, int& numLocalEqnBlks,
00388                       int& localBlkOffset);
00389 
00390    snl_fei::PointBlockMap& getBlkEqnMapper() {return(*blkEqnMapper_);}
00391 
00392    void destroyMatIndices();
00393 
00394    int getNumMultConstRecords() {return(multCRs_.size());};
00395 
00396    std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
00397      getMultConstRecords()
00398      {return(multCRs_);};
00399 
00400    int getMultConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& multCR)
00401    {
00402      std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
00403        cr_iter = multCRs_.find(CRID);
00404      int returncode = -1;
00405      if (cr_iter != multCRs_.end()) {
00406        multCR = (*cr_iter).second;
00407        returncode = 0;
00408      }
00409 
00410      return( returncode );
00411    }
00412 
00413    int getNumPenConstRecords() {return(penCRs_.size());}
00414    std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
00415      getPenConstRecords()
00416      { return(penCRs_); }
00417 
00418    int getPenConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& penCR)
00419    {
00420      std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
00421        cr_iter = penCRs_.find(CRID);
00422      int returncode = -1;
00423      if (cr_iter != penCRs_.end()) {
00424        penCR = (*cr_iter).second;
00425        returncode = 0;
00426      }
00427 
00428      return( returncode );
00429    }
00430 
00431    void addSlaveVariable(SlaveVariable* svar) {slaveVars_->push_back(svar);}
00432 
00433    int calculateSlaveEqns(MPI_Comm comm);
00434 
00435    fei::FillableMat* getSlaveDependencies() {return(slaveMatrix_);}
00436 
00437    EqnBuffer* getSlaveEqns() { return(slaveEqns_); }
00438 
00439    int numSlaveEquations() { return(numSlvs_); }
00440 
00443    bool isSlaveEqn(int eqn);
00444 
00453    bool translateToReducedEqn(int eqn, int& reducedEqn);
00454 
00459    int translateToReducedEqns(EqnCommMgr& eqnCommMgr);
00460 
00465    int translateToReducedEqns(EqnBuffer& eqnBuf);
00466 
00471    int translateToReducedEqns(ProcEqns& procEqns);
00472 
00477    int translateMatToReducedEqns(fei::CSRMat& mat);
00478 
00484    int translateFromReducedEqn(int reducedEqn);
00485 
00492    int getMasterEqnNumbers(int slaveEqn, std::vector<int>*& masterEqns);
00493 
00500    int getMasterEqnCoefs(int slaveEqn, std::vector<double>*& masterCoefs);
00501 
00509    int getMasterEqnRHS(int slaveEqn, double& rhsValue);
00510 
00511    int getNumGlobalEqns() { return( numGlobalEqns_ ); }
00512    int getNumLocalEqns() { return( numLocalEqns_ ); }
00513    int getFirstLocalEqn() { return( localStartRow_ ); }
00514    int getLastLocalEqn() { return( localEndRow_ ); }
00515 
00516    int getFirstReducedEqn() { return( reducedStartRow_ ); }
00517    int getLastReducedEqn()  { return( reducedEndRow_   ); }
00518 
00519    int getNumGlobalEqnBlks() { return( numGlobalEqnBlks_ ); }
00520    int getNumLocalEqnBlks() { return( numLocalEqnBlks_ ); }
00521    int getNumLocalReducedEqnBlks() { return( numLocalReducedEqnBlks_ ); }
00522    int getGlobalMaxBlkSize() { return(globalMaxBlkSize_); }
00523 
00524    int getNumLocalReducedEqns() { return( numLocalReducedRows_ ); }
00525 
00526    int getMatrixRowLengths(std::vector<int>& rowLengths);
00527    int getMatrixStructure(int** colIndices, std::vector<int>& rowLengths);
00528 
00529    int getMatrixStructure(int** ptColIndices, std::vector<int>& ptRowLengths,
00530         int** blkColIndices, int* blkIndices_1D,
00531         std::vector<int>& blkRowLengths,
00532         std::vector<int>& numPtRowsPerBlkRow);
00533 
00534    static int gatherSlaveEqns(MPI_Comm comm,
00535             EqnCommMgr* eqnCommMgr,
00536             EqnBuffer* slaveEqns);
00537 
00538    static int removeCouplings(EqnBuffer& eqnbuf, int& levelsOfCoupling);
00539 
00540    int calcTotalNumElemDOF();
00541    int calcNumMultCREqns();
00542 
00543    MPI_Comm getCommunicator() const { return( comm_ ); }
00544 
00545 #ifdef FEI_HAVE_IOSFWD
00546    int setDbgOut(std::ostream& ostr, const char* path, const char* feiName);
00547 #else
00548    int setDbgOut(ostream& ostr, const char* path, const char* feiName);
00549 #endif
00550 
00551  private:
00552 
00556    NodeDescriptor* findNode(GlobalID nodeID);
00560    NodeDescriptor& findNodeDescriptor(GlobalID nodeID);
00561 
00562    int writeEqn2NodeMap();
00563 
00564    int getElemNodeDescriptors(int blockIndex, int elemIndex,
00565                               NodeDescriptor** nodes);
00566 
00567    int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
00568            int fieldID,
00569            int* scatterIndices, int& offset);
00570 
00571    int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
00572            int fieldID,
00573            int* scatterIndices, int& offset,
00574            int* blkScatterIndices,
00575            int* blkSizes, int& blkOffset);
00576 
00577    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00578                            int** fieldIDs, int* fieldsPerNode,
00579                            int* scatterIndices, int& offset);
00580 
00581    int getNodeBlkIndices(NodeDescriptor** nodes, int numNodes,
00582        int* scatterIndices, int& offset);
00583 
00584    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00585                            int** fieldIDs, int* fieldsPerNode,
00586                            int* scatterIndices, int& offset,
00587          int* blkScatterIndices,
00588          int* blkSizes, int& blkOffset);
00589 
00590    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00591                            std::vector<int>* fieldIDs,
00592                            std::vector<int>& fieldsPerNode,
00593                            std::vector<int>& scatterIndices);
00594 
00595    int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
00596                             int** fieldIDs, int* fieldsPerNode,
00597                             int* scatterIndices, int& offset);
00598 
00599    int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
00600                                           std::vector<int>* fieldIDs,
00601                                           std::vector<int>& fieldsPerNode,
00602                                           std::vector<int>& scatterIndices);
00603 
00604    void calcGlobalEqnInfo(int numLocallyOwnedNodes, 
00605         int numLocalEqns,
00606         int numLocalEqnBlks);
00607 
00608    int finalizeActiveNodes();
00609    int finalizeNodeCommMgr();
00610    bool activeNodesInitialized();
00611 
00612    int formMatrixStructure();
00613 
00614    int initElemBlockStructure();
00615    int initMultCRStructure();
00616    int initPenCRStructure();
00617    int createMatrixPosition(int row, int col, const char* callingFunction);
00618    int createMatrixPositions(int row, int numCols, int* cols,
00619            const char* callingFunction);
00620    int createMatrixPositions(fei::CSRMat& mat);
00621 
00622    int createSymmEqnStructure(std::vector<int>& scatterIndices);
00623    int createBlkSymmEqnStructure(std::vector<int>& scatterIndices);
00624 
00625    int storeElementScatterIndices(std::vector<int>& scatterIndices);
00626    int storeElementScatterIndices_noSlaves(std::vector<int>& scatterIndices);
00627    int storeElementScatterBlkIndices_noSlaves(std::vector<int>& scatterIndices);
00628 
00629    void storeLocalNodeIndices(NodeDescriptor& iNode, int iField,
00630                                      NodeDescriptor& jNode, int jField);
00631    void storeNodalColumnIndices(int eqn, NodeDescriptor& node,
00632                  int fieldID);
00633    void storeNodalRowIndices(NodeDescriptor& node, int fieldID, int eqn);
00634    void storeNodalSendIndex(NodeDescriptor& node, int fieldID, int col);
00635    void storeNodalSendIndices(NodeDescriptor& iNode, int iField,
00636                                   NodeDescriptor& jNode, int jField);
00637 
00638    int assembleReducedStructure();
00639 
00640    bool nodalEqnsAllSlaves(const NodeDescriptor* node, std::vector<int>& slaveEqns);
00641 
00642    int initializeBlkEqnMapper();
00643 
00644    int setNumNodesAndEqnsPerBlock();
00645 
00646    void destroyBlockRoster();
00647 
00648 #ifdef FEI_HAVE_IOSFWD
00649    std::ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
00650 #else
00651    ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
00652 #endif
00653 
00654    void addCR(int CRID,
00655        snl_fei::Constraint<GlobalID>*& cr,
00656        std::map<GlobalID,snl_fei::Constraint<GlobalID>* >& crDB);
00657 
00658    int setNodalEqnInfo();
00659    void setElemDOFEqnInfo();
00660    int setMultCREqnInfo();
00661 
00662    SNL_FEI_Structure(const SNL_FEI_Structure& src);
00663    SNL_FEI_Structure& operator=(const SNL_FEI_Structure& src);
00664 
00665    MPI_Comm comm_;
00666 
00667    int localProc_, masterProc_, numProcs_;
00668 
00669    std::vector<int> fieldIDs_;
00670    std::vector<int> fieldSizes_;
00671    std::map<int,int>* fieldDatabase_;
00672    fei::FieldDofMap<int> fieldDofMap_;
00673    std::vector<int> workarray_;
00674 
00675    std::vector<GlobalID> blockIDs_;
00676    std::vector<BlockDescriptor*> blocks_;
00677    std::vector<ConnectivityTable*> connTables_;
00678 
00679    NodeDatabase* nodeDatabase_;
00680 
00681    bool activeNodesInitialized_;
00682 
00683    std::vector<int> globalNodeOffsets_;
00684    std::vector<int> globalEqnOffsets_;
00685    std::vector<int> globalBlkEqnOffsets_;
00686 
00687    std::vector<SlaveVariable*>* slaveVars_;
00688    EqnBuffer* slaveEqns_;
00689    std::vector<int>* slvEqnNumbers_;
00690    int numSlvs_, lowestSlv_, highestSlv_;
00691    fei::FillableMat* slaveMatrix_;
00692    std::vector<int> globalNumNodesVanished_;
00693    std::vector<int> localVanishedNodeNumbers_;
00694 
00695    NodeCommMgr* nodeCommMgr_;
00696    EqnCommMgr* eqnCommMgr_;
00697    EqnCommMgr* slvCommMgr_;
00698 
00699    int numGlobalEqns_;
00700    int numLocalEqns_;
00701    int localStartRow_;
00702    int localEndRow_;
00703 
00704    int numLocalNodalEqns_;
00705    int numLocalElemDOF_;
00706    int numLocalMultCRs_;
00707 
00708    int reducedStartRow_, reducedEndRow_, numLocalReducedRows_;
00709    fei::FillableMat *Kid_, *Kdi_, *Kdd_;
00710    fei::CSRMat csrD, csrKid, csrKdi, csrKdd, tmpMat1_, tmpMat2_;
00711    int reducedEqnCounter_, reducedRHSCounter_;
00712    std::vector<int> rSlave_, cSlave_;
00713    std::vector<NodeDescriptor*> work_nodePtrs_;
00714 
00715    bool structureFinalized_;
00716    bool generateGraph_;
00717 
00718    fei::ctg_set<int>* sysMatIndices_;
00719 
00720    bool blockMatrix_;
00721    int numGlobalEqnBlks_;
00722    int numLocalEqnBlks_;
00723    int numLocalReducedEqnBlks_;
00724    int localBlkOffset_;
00725    int localReducedBlkOffset_;
00726    int globalMaxBlkSize_;
00727 
00728    int firstLocalNodeNumber_;
00729    int numGlobalNodes_;
00730 
00731    fei::ctg_set<int>* sysBlkMatIndices_;
00732    bool matIndicesDestroyed_;
00733 
00734    std::vector<int> workSpace_;
00735 
00736    snl_fei::PointBlockMap* blkEqnMapper_;
00737 
00738    std::map<GlobalID, snl_fei::Constraint<GlobalID>* > multCRs_;
00739 
00740    std::map<GlobalID, snl_fei::Constraint<GlobalID>* > penCRs_;
00741 
00742    bool checkSharedNodes_;
00743 
00744    std::string name_;
00745 
00746    int outputLevel_;
00747    bool debugOutput_;
00748    std::string dbgPath_;
00749 #ifdef FEI_HAVE_IOSFWD
00750    std::ostream* dbgOStreamPtr_;
00751 #else
00752    ostream* dbgOStreamPtr_;
00753 #endif
00754    bool setDbgOutCalled_;
00755 };
00756 
00757 #endif
00758 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Friends