fei_EqnCommMgr.hpp

Go to the documentation of this file.

#ifndef _fei_EqnCommMgr_hpp_
#define _fei_EqnCommMgr_hpp_
 
/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#include "fei_fwd.hpp"
#include "fei_mpi.h"
 
#include "snl_fei_PointBlockMap.hpp"
 
#include <fei_CSRMat.hpp>
#include <fei_CSVec.hpp>
#include <fei_CommUtils.hpp>
#include "fei_ProcEqns.hpp"
#include "fei_EqnBuffer.hpp"
 
class EqnCommMgr {
 public:
   EqnCommMgr(MPI_Comm comm, bool accumulate = true);
 
   EqnCommMgr(const EqnCommMgr& src);
 
   EqnCommMgr& operator=(const EqnCommMgr& src);
 
   virtual ~EqnCommMgr();
 
   EqnCommMgr* deepCopy();
 
   size_t getNumSharingProcs() {return(recvProcEqns_->getNumProcs());};
   std::vector<int>& sharingProcsPtr() {return(recvProcEqns_->procsPtr());};
 
   size_t getNumOwnerProcs() {return(sendProcEqns_->getNumProcs());};
   std::vector<int>& ownerProcsPtr() {return(sendProcEqns_->procsPtr());};
 
   void addLocalEqn(int eqnNumber, int srcProc);
 
   void addSolnValues(int* eqnNumbers, double* values, int num);
 
#ifdef FEI_HAVE_IOSFWD
   int exchangeIndices(std::ostream* dbgOut=NULL);
   int exchangeEqns(std::ostream* dbgOut=NULL);
#else
   int exchangeIndices(ostream* dbgOut=NULL);
   int exchangeEqns(ostream* dbgOut=NULL);
#endif
 
   void exchangeSoln();
 
   int mirrorProcEqns(ProcEqns& inProcEqns, ProcEqns& outProcEqns);
 
   int mirrorProcEqnLengths(ProcEqns& inProcEqns,
          ProcEqns& outProcEqns);
 
 
   static int exchangeEqnBuffers(MPI_Comm comm, ProcEqns* sendProcEqns,
         EqnBuffer* sendEqns, ProcEqns* recvProcEqns,
         EqnBuffer* recvEqns, bool accumulate);
 
   int getNumLocalEqns() {return(recvEqns_->getNumEqns());};
 
   std::vector<int>& localEqnNumbers() {return(recvEqns_->eqnNumbers());};
   std::vector<fei::CSVec*>& localEqns(){return(recvEqns_->eqns());};
   std::vector<std::vector<double>*>* localRHSsPtr()
     {return(recvEqns_->rhsCoefsPtr());};
 
   int addRemoteEqn(int eqnNumber, int destProc, const double* coefs,
                   const int* indices, int num);
 
   int addRemoteEqn(int eqnNumber, const double* coefs,
        const int* indices, int num);
 
   int addRemoteEqns(fei::CSRMat& mat, bool onlyIndices);
   int addRemoteRHS(fei::CSVec& vec, int rhsIndex);
 
   void setNumRHSs(int numRHSs);
 
   int addRemoteRHS(int eqnNumber, int destProc, int rhsIndex, double value);
 
   int addRemoteRHS(int eqnNumber, int rhsIndex, double value);
 
   void addRemoteIndices(int eqnNumber, int destProc, int* indices, int num);
 
   int getNumRemoteEqns() {return(sendEqns_->getNumEqns());};
 
   std::vector<int>& sendEqnNumbersPtr() {return(sendEqns_->eqnNumbers());};
 
   double* sendEqnSolnPtr() {return(sendEqnSoln_.size()>0? &sendEqnSoln_[0] : NULL);};
 
   void resetCoefs();
 
   int gatherSharedBCs(EqnBuffer& bcEqns);
 
   int exchangeRemEssBCs(int* essEqns, int numEssEqns, double* essAlpha,
       double* essGamma, MPI_Comm comm,
       std::ostream* dbgOut = NULL);
 
   int getNumRemEssBCEqns() {return(essBCEqns_->getNumEqns());};
   std::vector<int>& remEssBCEqnNumbersPtr() {return(essBCEqns_->eqnNumbers());};
   std::vector<fei::CSVec*>& remEssBCEqns() {return(essBCEqns_->eqns());};
 
   int exchangePtToBlkInfo(snl_fei::PointBlockMap& blkEqnMapper);
 
   bool newCoefData() {if (recvEqns_->newCoefData_>0) return(true);
                       else return(false);}
   bool newRHSData() {if (recvEqns_->newRHSData_>0) return(true);
                      else return(false);}
 
   bool accumulate_;
 
   EqnBuffer* getRecvEqns() { return( recvEqns_ ); }
   EqnBuffer* getSendEqns() { return( sendEqns_ ); }
   ProcEqns* getRecvProcEqns() { return( recvProcEqns_ ); }
   ProcEqns* getSendProcEqns() { return( sendProcEqns_ ); }
 
 private:
   void deleteEssBCs();
   int getSendProcNumber(int eqn);
 
   int consistencyCheck(const char* caller,
      std::vector<int>& recvProcs,
      std::vector<int>& recvProcTotalLengths,
      std::vector<int>& sendProcs,
      std::vector<int>& sendProcTotalLengths);
 
   int localProc_;
 
   ProcEqns* recvProcEqns_;
 
   bool exchangeIndicesCalled_; //whether or not the exchangeIndices function
                                //has been called yet.
 
   EqnBuffer* recvEqns_;
 
   std::vector<double> solnValues_; //solution values we'll need to return to the
                              //processors that contribute to our equations
 
   ProcEqns* sendProcEqns_;
 
   EqnBuffer* sendEqns_;
 
   std::vector<double> sendEqnSoln_; 
                          //the solution values for the send equations. i.e.,
                          //we'll recv these solution values for the equations
                          //that we contributed to (sent) for other processors.
 
   EqnBuffer* essBCEqns_;
 
   MPI_Comm comm_;
};
 
#endif