---

EquationSet.h

Go to the documentation of this file.

#ifndef EQUATIONSET_H
#define EQUATIONSET_H

#include "SundanceDefs.h"


#include "EssentialBC.h"
#include "WeakForm.h"
#include "AbstractFunctionSpace.h"
#include "GaussLegendre.h"
#include "TSFNonDupArray.h"
#include "BasisFamily.h"
#include "TSFHashtable.h"
#include "ParametricVectorElement.h"
#include "ParametricMatrixElement.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  /** \ingroup LowLevelFE
   * Equation set is a collection of all
   * variational equations and boundary conditions pertinent to a
   * problem, listed by CellSet.  An equationSet also contains a
   * specification of the block structure of the unknown and test
   * function spaces.
   *
   * The information contained in an equation set is sufficient to build
   * a table of weak forms for the problem. However, the equation set
   * contains no information about the mesh and thus cannot by itself produce
   * discrete function spaces or DOF maps. The discrete function spaces
   * are created in the createRowSpace and createColSpace methods which take
   * the problem mesh as an argument.
   */

  class EquationSet
    {
    public:
      /** empty ctor */
      EquationSet();

      /** construct an EquationSet given a variational equation with
       * no replace-style essential boundary conditions. The ExprArray
       * arguments specify the block structure of the unknown
       * and test spaces.*/

      EquationSet(const ExprArray& test, const ExprArray& unk,
                  const Expr& integral);
      /** construct an EquationSet given a variational equation plus
       * replace-style essential boundary conditions. The ExprArray
       * arguments specify the block structure of the unknown and test
       * spaces.*/
      EquationSet(const ExprArray& test, const ExprArray& unk,
                  const Expr& integral, const EssentialBC& bc);

      /** get the list of cell sets used by the equations */
      const TSFArray<CellSet>& getCellSets() const {return cellSets_;}

      /** get the list of one-forms that apply on the given cell set */
      const TSFArray<WeakForm>& oneFormList(int cellSet) const
        {return oneForms_[cellSet];}

      /** get the list of two-forms that apply on the given cell set */
      const TSFArray<WeakForm>& twoFormList(int cellSet) const
        {return twoForms_[cellSet];}

      /** get the unmeshed matrix elements for a block */
      const TSFArray<ParametricMatrixElement>& getParametricElements(int br,
                                                                     int bc) const
        {return parametricMatrixBlocks_[br][bc];}

      /** get the unmeshed vector elements for a block */
      const TSFArray<ParametricVectorElement>& getParametricElements(int br) const
        {return parametricVectorBlocks_[br];}



      /** create a discrete function space for the blockRow-th block
       * of the row space. */
      AbstractFunctionSpace createRowSpace(int blockRow,
                                           const Mesh& mesh) const ;

      /** create a discrete function space for the blockCol-th block
       * of the column space. */
      AbstractFunctionSpace createColSpace(int blockCol,
                                           const Mesh& mesh) const ;

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

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

      /** map a funcID of a test function to the reduced testID on
       * the blockRow-th block */
      int getReducedTestID(int blockRow, int testID) const ;

      /** map a funcID of a unknown function to the reduced unkID on
       * the blockCol-th block */
      int getReducedUnkID(int blockCol, int unkID) const ;

      /** return the number of parametric equations in a block row */
      int numTestParameters(int blockRow) const
        {return numTestParameters_[blockRow];}

      /** return the number of parametric unknowns in a block col */
      int numUnknownParameters(int blockCol) const
        {return numUnknownParameters_[blockCol];}

      /** indicate whether the blockRow-th row is a
       * parametric constraint */
      bool isParametricRow(int blockRow) const
        {return isParametricRow_[blockRow];}

      /** indicate whether the blockCol-th column is a
       * parametric variable */
      bool isParametricColumn(int blockCol) const
        {return isParametricColumn_[blockCol];}


      /** indicate whether the (blockRow, blockCol) block of the system
       * matrix is identically zero. Zero blocks are identified
       * during parsing of the symbolic equation at build time  */
      bool isZeroBlock(int blockRow, int blockCol) const
        {return isZeroBlockMatrix_[blockRow][blockCol];}

      /** indicate whether the blockRow-th block of the system vector
       * is identically zero. Zero blocks are identified
       * during parsing of the symbolic equation at build time  */
      bool isZeroBlock(int blockRow) const
        {return isZeroBlockVector_[blockRow];}

      /** write to XML */
      XMLObject toXML() const ;

    private:

      /** initialization steps common to all ctors */
      void init(const Expr& integral, const EssentialBC& bc);

      /** add a new one-form to the one-form list. */
      void addOneForm(int cs, int blockRow, const Expr& var,
                      const Expr& coeff, const QuadratureFamily& quad,
                      bool isBC);

      /** add a new two-form to the one-form list. */
      void addTwoForm(int cs, int blockRow, int blockCol,
                      const Expr& var, const Expr& unk,
                      const Expr& coeff, const QuadratureFamily& quad,
                      bool isBC);


      /** group quadrature rules and expressions by cell set */
      void groupByCellSet(const Expr& eqns,
                          TSFArray<TSFArray<QuadratureFamily> >& quad,
                          TSFArray<ExprArray>& exprs,
                          ExprArray& parametricTermsInsideIntegrals,
                          ExprArray& fieldTermsOutsideIntegrals);


      /* list of all the cell sets that appear in the equation set. This
       * list is shared by all blocks. */
      TSFArray<CellSet> cellSets_;

      /* array giving the list of functions that are in each block row */
      ExprArray test_;

      /* array giving the list of functions that are in each block column */
      ExprArray unk_;

      /* list of one-forms for each cell set */
      TSFArray<TSFArray<WeakForm> > oneForms_;

      /* list of two-forms for each cell set */
      TSFArray<TSFArray<WeakForm> > twoForms_;

      /* matrix elements for unmeshed equations, listed by block index */
      TSFArray<TSFArray<TSFArray<ParametricMatrixElement> > >
        parametricMatrixBlocks_;

      /* vector elements for unmeshed equations, listed by block index */
      TSFArray<TSFArray<ParametricVectorElement> >
        parametricVectorBlocks_;


      /* map from test function funcID to position in the test array.
       * The array is a list of maps, one for each block row */
      TSFArray<TSFHashtable<int, int> > testIDToReducedIDMap_;

      /* map from unk function funcID to position in the unk array.
       * The array is a list of maps, one for each block column */
      TSFArray<TSFHashtable<int, int> > unkIDToReducedIDMap_;

      /* flags indicating whether each block row is a global constraint */
      TSFArray<bool> isParametricRow_;

      /* flags indicating whether each block column is a global unknown */
      TSFArray<bool> isParametricColumn_;

      /* number of parametric equations per block row */
      TSFArray<int> numTestParameters_;

      /* number of parametric unknowns per block column */
      TSFArray<int> numUnknownParameters_;

      /* flags indicating whether each block matrix has any nonzero terms */
      TSFArray<TSFArray<bool> > isZeroBlockMatrix_;

      /* flags indicating whether each block vector has any nonzero terms */
      TSFArray<bool>  isZeroBlockVector_;

      /* list of basis functions for each (cellSet, blockRow) pair */
      TSFArray<TSFArray<TSFNonDupArray<BasisFamily> > > testBasisList_;

      /* list of basis functions for each (cellSet, blockCol) pair */
      TSFArray<TSFArray<TSFNonDupArray<BasisFamily> > > unkBasisList_;

      /* list of domains for each function on each block row */
      TSFArray<TSFArray<TSFNonDupArray<CellSet> > > testDomainList_;

      /* list of domains for each function on each block col */
      TSFArray<TSFArray<TSFNonDupArray<CellSet> > > unkDomainList_;

      /* */
      static bool verbose_;
    };

  /** \relates EquationSet write to a stream */
  inline ostream& operator<<(ostream& os, EquationSet& eqnSet)
    {
      return os << eqnSet.toXML();
    }

}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by