fei_EqnCommMgr.hpp

#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