FEI Version of the Day
SNL_FEI_Structure.hpp
00001 #ifndef _SNL_FEI_Structure_hpp_
00002 #define _SNL_FEI_Structure_hpp_
00003 
00004 /*--------------------------------------------------------------------*/
00005 /*    Copyright 2005 Sandia Corporation.                              */
00006 /*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
00007 /*    non-exclusive license for use of this work by or on behalf      */
00008 /*    of the U.S. Government.  Export of this program may require     */
00009 /*    a license from the United States Government.                    */
00010 /*--------------------------------------------------------------------*/
00011 
00012 #include <fei_fwd.hpp>
00013 #include <fei_defs.h>
00014 #include <fei_constants.hpp>
00015 #include "fei_TemplateUtils.hpp"
00016 #include <snl_fei_PointBlockMap.hpp>
00017 #include <fei_EqnBuffer.hpp>
00018 #include <fei_FieldDofMap.hpp>
00019 #include <fei_CSRMat.hpp>
00020 #include <fei_CSVec.hpp>
00021 
00022 #include <fei_NodeCommMgr.hpp>
00023 #include <fei_NodeDatabase.hpp>
00024 #include <fei_NodeDescriptor.hpp>
00025 
00026 #include <fei_Lookup.hpp>
00027 
00043 class SNL_FEI_Structure : public Lookup {
00044  public:
00053    SNL_FEI_Structure(MPI_Comm comm);
00054 
00056    virtual ~SNL_FEI_Structure();
00057 
00073    int parameters(int numParams, const char*const* paramStrings);
00074 
00075    int initFields(int numFields, const int* fieldSizes, const int* fieldIDs,
00076                   const int* fieldTypes = NULL);
00077 
00078    int initElemBlock(GlobalID elemBlockID,
00079          int numElements,
00080          int numNodesPerElement,
00081          const int* numFieldsPerNode,
00082          const int* const* nodalFieldIDs,
00083          int numElemDofFieldsPerElement,
00084          const int* elemDofFieldIDs,
00085          int interleaveStrategy);
00086 
00087    int initElem(GlobalID elemBlockID,
00088     GlobalID elemID,
00089     const GlobalID* elemConn);
00090 
00091    int initSlaveVariable(GlobalID slaveNodeID, 
00092        int slaveFieldID,
00093        int offsetIntoSlaveField,
00094        int numMasterNodes,
00095        const GlobalID* masterNodeIDs,
00096        const int* masterFieldIDs,
00097        const double* weights,
00098        double rhsValue);
00099 
00100    int deleteMultCRs();
00101 
00102    int initSharedNodes(int numSharedNodes,
00103            const GlobalID *sharedNodeIDs,  
00104            const int* numProcsPerNode, 
00105            const int *const *sharingProcIDs);
00106 
00107    // constraint relation initialization
00108    //- lagrange multiplier formulation
00109    int initCRMult(int numCRNodes,
00110       const GlobalID* CRNodes,
00111       const int *CRFields,
00112       int& CRID);
00113 
00114    // - penalty function formulation
00115    int initCRPen(int numCRNodes,
00116      const GlobalID* CRNodes, 
00117      const int *CRFields,
00118      int& CRID); 
00119 
00120    int initComplete(bool generateGraph = true);
00121 
00122    const std::vector<int>& getFieldIDs() const
00123      { return fieldIDs_; }
00124 
00126    const int* getFieldIDsPtr()
00127      {
00128        int len = fieldDatabase_->size();
00129        workarray_.resize(len*2);
00130        fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
00131              &workarray_[0],
00132              &workarray_[0]+len);
00133        return( &workarray_[0] );
00134      }
00135 
00137    const int* getFieldSizesPtr()
00138      {
00139        int len = fieldDatabase_->size();
00140        workarray_.resize(len*2);
00141        fei::copyToArrays<std::map<int,int> >(*fieldDatabase_, len,
00142              &workarray_[0],
00143              &workarray_[0]+len);
00144        return( &workarray_[0]+len );
00145      }
00146 
00148    int getNumFields() { return( fieldDatabase_->size() ); };
00149 
00151    int getFieldSize(int fieldID)
00152      {
00153        std::map<int,int>::const_iterator
00154    f_iter = fieldDatabase_->find(fieldID);
00155 
00156        return(f_iter != fieldDatabase_->end() ? (*f_iter).second : -1);
00157      }
00158 
00159    fei::FieldDofMap<int>& getFieldDofMap()
00160      { return fieldDofMap_; }
00161 
00163    bool isInLocalElement(int nodeNumber);
00164 
00165    const int* getNumFieldsPerNode(GlobalID blockID);
00166 
00167    const int* const* getFieldIDsTable(GlobalID blockID);
00168 
00173    int getEqnNumber(int nodeNumber, int fieldID);
00174 
00181    int getOwnerProcForEqn(int eqn);
00182 
00183 
00185    //now the element-block functions
00186 
00187    int getNumElemBlocks() {return(blockIDs_.size());};
00188    const GlobalID* getElemBlockIDs() {return(&blockIDs_[0]);};
00189 
00190    void getElemBlockInfo(GlobalID blockID,
00191                          int& interleaveStrategy, int& lumpingStrategy,
00192                          int& numElemDOF, int& numElements,
00193                          int& numNodesPerElem, int& numEqnsPerElem);
00194 
00195    int addBlock(GlobalID blockID);
00196 
00197    int getBlockDescriptor(GlobalID blockID, BlockDescriptor*& block);
00198 
00202    int getBlockDescriptor_index(int index, BlockDescriptor*& block);
00203 
00205    int getIndexOfBlock(GlobalID blockID) const;
00207    int getBlockID(unsigned index) const
00208    {
00209      if (index < blockIDs_.size()) return blockIDs_[index];
00210      return -1;
00211    }
00212 
00213    int allocateBlockConnectivity(GlobalID blockID);
00214    void destroyConnectivityTables();
00215 
00216    ConnectivityTable& getBlockConnectivity(GlobalID blockID);
00217 
00218    void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
00219                              int interleaveStrategy,
00220                              int* scatterIndices);
00221 
00222    void getScatterIndices_index(int blockIndex, int elemIndex,
00223                              int interleaveStrategy,
00224                              int* scatterIndices);
00225 
00226    int getBlkScatterIndices_index(int blockIndex,
00227           int elemIndex,
00228           int* scatterIndices);
00229 
00230    void getScatterIndices_ID(GlobalID blockID, GlobalID elemID,
00231                              int interleaveStrategy,
00232                              int* scatterIndices,
00233            int* blkScatterIndices,
00234            int* blkSizes);
00235 
00236    void getScatterIndices_index(int blockIndex, int elemIndex,
00237                              int interleaveStrategy,
00238                              int* scatterIndices,
00239            int* blkScatterIndices,
00240         int* blkSizes);
00241 
00242 
00244    //now the shared-node lookup functions from the Lookup interface.
00245 
00246    int getNumSharedNodes() {return(nodeCommMgr_->getNumSharedNodes());};
00247 
00248    const int* getSharedNodeNumbers() {
00249       return(&(nodeCommMgr_->getSharedNodeNumbers())[0]);
00250    };
00251 
00252    const int* getSharedNodeProcs(int nodeNumber) {
00253       int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
00254       if (index < 0) return(NULL);
00255       return(&(nodeCommMgr_->getSharedNodeProcs(index))[0]);
00256    };
00257 
00258    int getNumSharingProcs(int nodeNumber) {
00259       int index = nodeCommMgr_->getSharedNodeIndex_num(nodeNumber);
00260       if (index < 0) return(-1);
00261       return(nodeCommMgr_->getSharedNodeProcs(index).size());
00262    };
00263 
00264    int getNumSubdomains(int nodeNumber) {
00265      const NodeDescriptor* node = NULL;
00266      int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
00267      if (err != 0) return(-1);
00268      GlobalID nodeID = node->getGlobalNodeID();
00269      return(nodeCommMgr_->getSharedNodeNumSubdomains(nodeID));
00270    }
00271 
00272    int* getSubdomainList(int nodeNumber) {
00273      const NodeDescriptor* node = NULL;
00274      int err = nodeDatabase_->getNodeWithNumber(nodeNumber, node);
00275      if (err != 0) return(NULL);
00276      GlobalID nodeID = node->getGlobalNodeID();
00277      return(&(*(nodeCommMgr_->getSharedNodeSubdomainList(nodeID)))[0]);
00278 
00279    }
00280 
00281    int translateToReducedNodeNumber(int nodeNumber, int proc);
00282 
00284 
00286    int getAssociatedNodeNumber(int eqnNumber)
00287      {
00288        int eqn = translateFromReducedEqn(eqnNumber);
00289        int nodeNumber = nodeDatabase_->getAssociatedNodeNumber(eqn);
00290        int reducedNodeNumber = -1;
00291        if (nodeNumber >= 0) {
00292    reducedNodeNumber = translateToReducedNodeNumber(nodeNumber, localProc_);
00293        }
00294        return( reducedNodeNumber );
00295      }
00296 
00298    int getAssociatedFieldID(int eqnNumber)
00299      {
00300        int eqn = translateFromReducedEqn(eqnNumber);
00301        return( nodeDatabase_->getAssociatedFieldID(eqn) );
00302      }
00303 
00304 
00306    //now the point-eqn to block-eqn queries...
00307 
00308    bool isExactlyBlkEqn(int ptEqn) {
00309       return(blkEqnMapper_->isExactlyBlkEqn(ptEqn));
00310    };
00311 
00312    int ptEqnToBlkEqn(int ptEqn) {
00313       return(blkEqnMapper_->eqnToBlkEqn(ptEqn));
00314    };
00315  
00316    int getOffsetIntoBlkEqn(int blkEqn, int ptEqn) {
00317       return(blkEqnMapper_->getBlkEqnOffset(blkEqn, ptEqn));
00318    };
00319 
00320    int getBlkEqnSize(int blkEqn) {
00321       return(blkEqnMapper_->getBlkEqnSize(blkEqn));
00322    }
00324 
00325 
00326    int getNumActiveNodes() {return(nodeDatabase_->getNodeIDs().size());}
00327 
00328    NodeDatabase& getNodeDatabase() { return( *nodeDatabase_ ); }
00329 
00330    std::map<GlobalID,int>& getActiveNodeIDList()
00331      { return( nodeDatabase_->getNodeIDs() ); }
00332 
00333    std::vector<int>& getGlobalNodeOffsets() {return(globalNodeOffsets_);}
00334    std::vector<int>& getGlobalEqnOffsets() {return(globalEqnOffsets_);}
00335    std::vector<int>& getGlobalBlkEqnOffsets() {return(globalBlkEqnOffsets_);}
00336 
00337    NodeCommMgr& getNodeCommMgr() {return(*nodeCommMgr_);}
00338    EqnCommMgr&  getEqnCommMgr()  {return(*eqnCommMgr_ );}
00339 
00340    void initializeEqnCommMgr();
00341 
00342    void getEqnInfo(int& numGlobalEqns, int& numLocalEqns,
00343                    int& localStartRow, int& localEndRow);
00344 
00345    int getEqnNumbers(GlobalID ID, int idType, int fieldID,
00346          int& numEqns, int* eqnNumbers);
00347 
00348    int getEqnNumbers(int numIDs, const GlobalID* IDs,
00349          int idType, int fieldID,
00350          int& numEqns, int* eqnNumbers);
00351 
00352    void getEqnBlkInfo(int& numGlobalEqnBlks, int& numLocalEqnBlks,
00353                       int& localBlkOffset);
00354 
00355    snl_fei::PointBlockMap& getBlkEqnMapper() {return(*blkEqnMapper_);}
00356 
00357    void destroyMatIndices();
00358 
00359    int getNumMultConstRecords() {return(multCRs_.size());};
00360 
00361    std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
00362      getMultConstRecords()
00363      {return(multCRs_);};
00364 
00365    int getMultConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& multCR)
00366    {
00367      std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
00368        cr_iter = multCRs_.find(CRID);
00369      int returncode = -1;
00370      if (cr_iter != multCRs_.end()) {
00371        multCR = (*cr_iter).second;
00372        returncode = 0;
00373      }
00374 
00375      return( returncode );
00376    }
00377 
00378    int getNumPenConstRecords() {return(penCRs_.size());}
00379    std::map<GlobalID,snl_fei::Constraint<GlobalID>*>&
00380      getPenConstRecords()
00381      { return(penCRs_); }
00382 
00383    int getPenConstRecord(int CRID, snl_fei::Constraint<GlobalID>*& penCR)
00384    {
00385      std::map<int,snl_fei::Constraint<GlobalID>*>::iterator
00386        cr_iter = penCRs_.find(CRID);
00387      int returncode = -1;
00388      if (cr_iter != penCRs_.end()) {
00389        penCR = (*cr_iter).second;
00390        returncode = 0;
00391      }
00392 
00393      return( returncode );
00394    }
00395 
00396    void addSlaveVariable(SlaveVariable* svar) {slaveVars_->push_back(svar);}
00397 
00398    int calculateSlaveEqns(MPI_Comm comm);
00399 
00400    fei::FillableMat* getSlaveDependencies() {return(slaveMatrix_);}
00401 
00402    EqnBuffer* getSlaveEqns() { return(slaveEqns_); }
00403 
00404    int numSlaveEquations() { return(numSlvs_); }
00405 
00408    bool isSlaveEqn(int eqn);
00409 
00418    bool translateToReducedEqn(int eqn, int& reducedEqn);
00419 
00424    int translateToReducedEqns(EqnCommMgr& eqnCommMgr);
00425 
00430    int translateToReducedEqns(EqnBuffer& eqnBuf);
00431 
00436    int translateToReducedEqns(ProcEqns& procEqns);
00437 
00442    int translateMatToReducedEqns(fei::CSRMat& mat);
00443 
00449    int translateFromReducedEqn(int reducedEqn);
00450 
00457    int getMasterEqnNumbers(int slaveEqn, std::vector<int>*& masterEqns);
00458 
00465    int getMasterEqnCoefs(int slaveEqn, std::vector<double>*& masterCoefs);
00466 
00474    int getMasterEqnRHS(int slaveEqn, double& rhsValue);
00475 
00476    int getNumGlobalEqns() { return( numGlobalEqns_ ); }
00477    int getNumLocalEqns() { return( numLocalEqns_ ); }
00478    int getFirstLocalEqn() { return( localStartRow_ ); }
00479    int getLastLocalEqn() { return( localEndRow_ ); }
00480 
00481    int getFirstReducedEqn() { return( reducedStartRow_ ); }
00482    int getLastReducedEqn()  { return( reducedEndRow_   ); }
00483 
00484    int getNumGlobalEqnBlks() { return( numGlobalEqnBlks_ ); }
00485    int getNumLocalEqnBlks() { return( numLocalEqnBlks_ ); }
00486    int getNumLocalReducedEqnBlks() { return( numLocalReducedEqnBlks_ ); }
00487    int getGlobalMaxBlkSize() { return(globalMaxBlkSize_); }
00488 
00489    int getNumLocalReducedEqns() { return( numLocalReducedRows_ ); }
00490 
00491    int getMatrixRowLengths(std::vector<int>& rowLengths);
00492    int getMatrixStructure(int** colIndices, std::vector<int>& rowLengths);
00493 
00494    int getMatrixStructure(int** ptColIndices, std::vector<int>& ptRowLengths,
00495         int** blkColIndices, int* blkIndices_1D,
00496         std::vector<int>& blkRowLengths,
00497         std::vector<int>& numPtRowsPerBlkRow);
00498 
00499    static int gatherSlaveEqns(MPI_Comm comm,
00500             EqnCommMgr* eqnCommMgr,
00501             EqnBuffer* slaveEqns);
00502 
00503    static int removeCouplings(EqnBuffer& eqnbuf, int& levelsOfCoupling);
00504 
00505    int calcTotalNumElemDOF();
00506    int calcNumMultCREqns();
00507 
00508    MPI_Comm getCommunicator() const { return( comm_ ); }
00509 
00510 #ifdef FEI_HAVE_IOSFWD
00511    int setDbgOut(std::ostream& ostr, const char* path, const char* feiName);
00512 #else
00513    int setDbgOut(ostream& ostr, const char* path, const char* feiName);
00514 #endif
00515 
00516  private:
00517 
00521    NodeDescriptor* findNode(GlobalID nodeID);
00525    NodeDescriptor& findNodeDescriptor(GlobalID nodeID);
00526 
00527    int writeEqn2NodeMap();
00528 
00529    int getElemNodeDescriptors(int blockIndex, int elemIndex,
00530                               NodeDescriptor** nodes);
00531 
00532    int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
00533            int fieldID,
00534            int* scatterIndices, int& offset);
00535 
00536    int getNodeIndices_simple(NodeDescriptor** nodes, int numNodes,
00537            int fieldID,
00538            int* scatterIndices, int& offset,
00539            int* blkScatterIndices,
00540            int* blkSizes, int& blkOffset);
00541 
00542    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00543                            int** fieldIDs, int* fieldsPerNode,
00544                            int* scatterIndices, int& offset);
00545 
00546    int getNodeBlkIndices(NodeDescriptor** nodes, int numNodes,
00547        int* scatterIndices, int& offset);
00548 
00549    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00550                            int** fieldIDs, int* fieldsPerNode,
00551                            int* scatterIndices, int& offset,
00552          int* blkScatterIndices,
00553          int* blkSizes, int& blkOffset);
00554 
00555    int getNodeMajorIndices(NodeDescriptor** nodes, int numNodes,
00556                            std::vector<int>* fieldIDs,
00557                            std::vector<int>& fieldsPerNode,
00558                            std::vector<int>& scatterIndices);
00559 
00560    int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
00561                             int** fieldIDs, int* fieldsPerNode,
00562                             int* scatterIndices, int& offset);
00563 
00564    int getFieldMajorIndices(NodeDescriptor** nodes, int numNodes,
00565                                           std::vector<int>* fieldIDs,
00566                                           std::vector<int>& fieldsPerNode,
00567                                           std::vector<int>& scatterIndices);
00568 
00569    void calcGlobalEqnInfo(int numLocallyOwnedNodes, 
00570         int numLocalEqns,
00571         int numLocalEqnBlks);
00572 
00573    int finalizeActiveNodes();
00574    int finalizeNodeCommMgr();
00575    bool activeNodesInitialized();
00576 
00577    int formMatrixStructure();
00578 
00579    int initElemBlockStructure();
00580    int initMultCRStructure();
00581    int initPenCRStructure();
00582    int createMatrixPosition(int row, int col, const char* callingFunction);
00583    int createMatrixPositions(int row, int numCols, int* cols,
00584            const char* callingFunction);
00585    int createMatrixPositions(fei::CSRMat& mat);
00586 
00587    int createSymmEqnStructure(std::vector<int>& scatterIndices);
00588    int createBlkSymmEqnStructure(std::vector<int>& scatterIndices);
00589 
00590    int storeElementScatterIndices(std::vector<int>& scatterIndices);
00591    int storeElementScatterIndices_noSlaves(std::vector<int>& scatterIndices);
00592    int storeElementScatterBlkIndices_noSlaves(std::vector<int>& scatterIndices);
00593 
00594    void storeLocalNodeIndices(NodeDescriptor& iNode, int iField,
00595                                      NodeDescriptor& jNode, int jField);
00596    void storeNodalColumnIndices(int eqn, NodeDescriptor& node,
00597                  int fieldID);
00598    void storeNodalRowIndices(NodeDescriptor& node, int fieldID, int eqn);
00599    void storeNodalSendIndex(NodeDescriptor& node, int fieldID, int col);
00600    void storeNodalSendIndices(NodeDescriptor& iNode, int iField,
00601                                   NodeDescriptor& jNode, int jField);
00602 
00603    int assembleReducedStructure();
00604 
00605    bool nodalEqnsAllSlaves(const NodeDescriptor* node, std::vector<int>& slaveEqns);
00606 
00607    int initializeBlkEqnMapper();
00608 
00609    int setNumNodesAndEqnsPerBlock();
00610 
00611    void destroyBlockRoster();
00612 
00613 #ifdef FEI_HAVE_IOSFWD
00614    std::ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
00615 #else
00616    ostream& dbgOut() { return( *dbgOStreamPtr_ ); }
00617 #endif
00618 
00619    void addCR(int CRID,
00620        snl_fei::Constraint<GlobalID>*& cr,
00621        std::map<GlobalID,snl_fei::Constraint<GlobalID>* >& crDB);
00622 
00623    int setNodalEqnInfo();
00624    void setElemDOFEqnInfo();
00625    int setMultCREqnInfo();
00626 
00627    SNL_FEI_Structure(const SNL_FEI_Structure& src);
00628    SNL_FEI_Structure& operator=(const SNL_FEI_Structure& src);
00629 
00630    MPI_Comm comm_;
00631 
00632    int localProc_, masterProc_, numProcs_;
00633 
00634    std::vector<int> fieldIDs_;
00635    std::vector<int> fieldSizes_;
00636    std::map<int,int>* fieldDatabase_;
00637    fei::FieldDofMap<int> fieldDofMap_;
00638    std::vector<int> workarray_;
00639 
00640    std::vector<GlobalID> blockIDs_;
00641    std::vector<BlockDescriptor*> blocks_;
00642    std::vector<ConnectivityTable*> connTables_;
00643 
00644    NodeDatabase* nodeDatabase_;
00645 
00646    bool activeNodesInitialized_;
00647 
00648    std::vector<int> globalNodeOffsets_;
00649    std::vector<int> globalEqnOffsets_;
00650    std::vector<int> globalBlkEqnOffsets_;
00651 
00652    std::vector<SlaveVariable*>* slaveVars_;
00653    EqnBuffer* slaveEqns_;
00654    std::vector<int>* slvEqnNumbers_;
00655    int numSlvs_, lowestSlv_, highestSlv_;
00656    fei::FillableMat* slaveMatrix_;
00657    std::vector<int> globalNumNodesVanished_;
00658    std::vector<int> localVanishedNodeNumbers_;
00659 
00660    NodeCommMgr* nodeCommMgr_;
00661    EqnCommMgr* eqnCommMgr_;
00662    EqnCommMgr* slvCommMgr_;
00663 
00664    int numGlobalEqns_;
00665    int numLocalEqns_;
00666    int localStartRow_;
00667    int localEndRow_;
00668 
00669    int numLocalNodalEqns_;
00670    int numLocalElemDOF_;
00671    int numLocalMultCRs_;
00672 
00673    int reducedStartRow_, reducedEndRow_, numLocalReducedRows_;
00674    fei::FillableMat *Kid_, *Kdi_, *Kdd_;
00675    fei::CSRMat csrD, csrKid, csrKdi, csrKdd, tmpMat1_, tmpMat2_;
00676    int reducedEqnCounter_, reducedRHSCounter_;
00677    std::vector<int> rSlave_, cSlave_;
00678    std::vector<NodeDescriptor*> work_nodePtrs_;
00679 
00680    bool structureFinalized_;
00681    bool generateGraph_;
00682 
00683    fei::ctg_set<int>* sysMatIndices_;
00684 
00685    bool blockMatrix_;
00686    int numGlobalEqnBlks_;
00687    int numLocalEqnBlks_;
00688    int numLocalReducedEqnBlks_;
00689    int localBlkOffset_;
00690    int localReducedBlkOffset_;
00691    int globalMaxBlkSize_;
00692 
00693    int firstLocalNodeNumber_;
00694    int numGlobalNodes_;
00695 
00696    fei::ctg_set<int>* sysBlkMatIndices_;
00697    bool matIndicesDestroyed_;
00698 
00699    std::vector<int> workSpace_;
00700 
00701    snl_fei::PointBlockMap* blkEqnMapper_;
00702 
00703    std::map<GlobalID, snl_fei::Constraint<GlobalID>* > multCRs_;
00704 
00705    std::map<GlobalID, snl_fei::Constraint<GlobalID>* > penCRs_;
00706 
00707    bool checkSharedNodes_;
00708 
00709    std::string name_;
00710 
00711    int outputLevel_;
00712    bool debugOutput_;
00713    std::string dbgPath_;
00714 #ifdef FEI_HAVE_IOSFWD
00715    std::ostream* dbgOStreamPtr_;
00716 #else
00717    ostream* dbgOStreamPtr_;
00718 #endif
00719    bool setDbgOutCalled_;
00720 };
00721 
00722 #endif
00723 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Friends