---

DistributedMatrixBuilder.h

Go to the documentation of this file.

#ifndef DISTRIBUTEDMATRIXBUILDER_H
#define DISTRIBUTEDMATRIXBUILDER_H

#include "SundanceDefs.h"

#include "WeakForm.h"
#include "TSFRBTree.h"
#include "DistributedDOFMap.h"
#include "TSFSmartPtr.h"
#include "CellType.h"
#include "Mesh.h"
#include "EssentialBC.h"
#include "EquationSet.h"
#include "TSFVector.h"
#include "TSFHashtable.h"
#include "WorkSet.h"
#include "CellBlock.h"
#include "TSFMatrixOperator.h"
#include "TSFMultiVectorOperator.h"
#include "TSFTimeMonitor.h"

namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;


  class LocalMatrix;

  /** \ingroup LowLevelFE
   * Distributed assembly of a matrix
   */

  class DistributedMatrixBuilder
    {
    public:
      /** */
      DistributedMatrixBuilder(const Mesh& mesh, const Expr& eqn,
                               const EssentialBC& bc,
                               const ExprArray& test, const ExprArray& unk);

      /** assemble all matrix blocks */
      void buildMatrix(TSFArray<TSFArray<TSFMatrixOperator*> >& mat,
                       TSFArray<TSFArray<TSFMultiVectorOperator*> >& mv) const ;


      /** assemble all blocks of the problem vector */
      void buildVector(TSFArray<TSFVector>& vec) const ;

      /** assemble all blocks involving geometric variables */
      void buildGeometricVector(TSFArray<TSFVector>& vec) const ;

      /** assemble all blocks involving parametric variables */
      void buildParametricVector(TSFArray<TSFVector>& vec) const ;

      /** */
      void buildSoln(int blockCol, const TSFVector& solnVec,
                     Expr& soln) const ;
      /** */
      void buildRHSExpr(int blockRow, const TSFVector& solnVec,
                        Expr& soln) const ;

      /** return the number of block rows */
      int numBlockRows() const {return var_.length();}

      /** return the number of block columns */
      int numBlockCols() const {return unk_.length();}

      /** flag to indicate whether matrix must be restructured */
      bool needsMatrixConfiguration(int blockRow, int blockCol) const
        {return needsMatrixConfiguration_[blockRow][blockCol];}

      /** */
      void flushConfiguration();

      /** */
      TSFVectorSpace createRowSpace(int blockRow,
                                    const TSFVectorType& vt) const ;

      /** */
      TSFVectorSpace createColumnSpace(int blockCol,
                                       const TSFVectorType& vt) const ;


      /** */
      bool isZeroBlock(int blockRow, int blockCol) const
        {return eqnSet_.isZeroBlock(blockRow, blockCol);}

      /** */
      void printRowMaps() const ;

      /** */
      void printColumnMaps() const ;

      /** */
      void showGraph(ostream& os) const ;

      /** */
      void showBCRows(ostream& os) const ;

      /** */
      static void verboseMatrixInsertion() {verboseMatrixInsertion_=true;}

      /** */
      static void verboseMatrixAssembly() {verboseMatrixAssembly_=true;}

      /** */
      static void verboseVectorInsertion() {verboseVectorInsertion_=true;}

      /** */
      static void verboseVectorAssembly() {verboseVectorAssembly_=true;}

      /** */
      static void quietMatrixInsertion() {verboseMatrixInsertion_=false;}

      /** */
      static void quietVectorInsertion() {verboseVectorInsertion_=false;}

      /** */
      static int& workSetSize() {static int wss=-1; return wss;}

    private:
      /** do initialization steps that are common to all ctors: build the DOF
       * maps, build work sets, and identify BC rows */
      void init();

      /** initialize the structure of the (blockRow, blockCol) submatrix */
      void configureMatrix(int blockRow, int blockCol,
                           TSFMatrixOperator* mat) const ;

      /** find the sparsity structure of the (blockRow, blockCol) submatrix */
      void getGraph(int blockRow, int blockCol,
                    TSFArray<TSFNonDupArray<int> >& columnIndices) const ;

      /** given a short list of rows, determine whether each is an update
       * and/or BC row */
      void getMarkedRows(int blockRow,
                         const TSFArray<int>& globalRowIndex,
                         TSFArray<bool>& isUpdate,
                         TSFArray<bool>& isBC) const ;

      /** mark a set of rows as BC rows */
      void setBCRows(int blockRow,
                     const TSFArray<int>& globalRowIndex);

      /** put the local matrix for the given weak form into the
       * given subblock of the global matrix */
      void insertLocalMatrix(bool isParametricRow,
                             bool isParametricCol,
                             int blockRow, int blockCol, int cellDim,
                             int cellIndex,
                             const WeakForm& wf,
                             const LocalMatrix& localMat,
                             TSFMatrixOperator* mat,
                             TSFMultiVectorOperator* mv) const ;

      /** put the local vector for the given weak form into the
       * given subblock of the global vector */
      void insertLocalVector(int blockRow, int cellDim,
                             int cellIndex,
                             const WeakForm& wf,
                             const DenseSerialVector& localVec,
                             TSFVector& vec) const ;

      /** put a batch of local matrices for the given weak form into the
       * given subblock of the global matrix */
      void insertLocalMatrixBatch(int blockRow, int blockCol,
                                  const WorkSet& workSet,
                                  const WeakForm& wf,
                                  const TSFArray<LocalMatrix>& localMat,
                                  TSFMatrixOperator* mat,
                                  TSFMultiVectorOperator* mv) const ;

      /** put a batch of local vectors for the given weak form into the
       * given subblock of the global vector */
      void insertLocalVectorBatch(int blockRow, const WorkSet& workSet,
                                  const WeakForm& wf,
                                  const TSFArray<DenseSerialVector>& localVec,
                                  TSFVector& vec) const ;

      /** print diagnostics during vector insertion */
      void showVectorInsertion(bool isBCTerm, int testID, double coeff,
                               const TSFArray<int>& rowIndices,
                               const TSFArray<bool>& isBCRow) const ;

      /** */
      void buildParametricBlocks(TSFArray<TSFArray<TSFMatrixOperator*> >& mat) const ;

      /** */
      void buildParametricVectorBlocks(TSFArray<TSFVector>& vec) const ;

      /** */
      void printGraph(int br, int bc,
                      const TSFArray<TSFNonDupArray<int> >& graph) const ;

      static int defaultWorkSetSize_;

      static bool verboseMatrixInsertion_;

      static bool verboseVectorInsertion_;

      static bool verboseMatrixAssembly_;

      static bool verboseVectorAssembly_;

      static bool verboseInit_;

      ExprArray var_;
      ExprArray unk_;

      Mesh mesh_;

      /* the equation set to be solved. */
      EquationSet eqnSet_;

      TSFArray<AbstractFunctionSpace> rowSpace_;
      TSFArray<AbstractFunctionSpace> colSpace_;
      TSFArray<TSFSmartPtr<DOFMapBase> > testDOFMap_;
      TSFArray<TSFSmartPtr<DOFMapBase> > unkDOFMap_;

      /* the BCRowTables indicate whether a given row is to be replaced
       * by an essential boundary condition. The localBCRowTable is for
       * locally-owned rows, remoteBCRowTable for non-locally owned rows. */
      TSFArray<TSFArray<bool> > localBCRowTable_;
      TSFArray<TSFHashtable<int, bool> > remoteBCRowTable_;

      TSFArray<TSFHashtable<CellTopologyCode, TSFSmartPtr<TSFArray<CellBlock> > > > cellBlocks_;
      TSFArray<TSFNonDupArray<CellTopologyCode> > cellTypes_;
      TSFHashtable<CellTopologyCode, TSFSmartPtr<WorkSet> > workSetTable_;

      int workSetSize_;

      mutable TSFArray<TSFArray<bool> > needsMatrixConfiguration_;

      static TSFTimer& initBuilderTimer();

      static TSFTimer& matrixConfigurationTimer();

      static TSFTimer& matrixAssemblyTimer();

      static TSFTimer& vectorAssemblyTimer();

      static TSFTimer& graphAssemblyTimer();

      static TSFTimer& matrixInsertionTimer();

      static TSFTimer& vectorInsertionTimer();


    };





}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by