---

WeakForm.h

Go to the documentation of this file.

#ifndef WEAKFORM_H
#define WEAKFORM_H

#include "SundanceDefs.h"

#include "Expr.h"
#include "BasisFamily.h"
#include "QuadratureFamily.h"
#include "MultiIndex.h"
#include "XMLObject.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  class EquationSet;

  /** \ingroup LowLevelFE
   *
   * In a finite elements problem one must do integrals of the form
   * \f[ \int_C f(x) D^{(\alpha)} \phi_t  D^{(\beta)} \phi_s \f]
   * to obtain matrix entries and integrals of the form
   * \f[ \int_C f(x) D^{(\alpha)} \phi_t \f] to obtain vector entries. Here
   * \f$ \phi_t \f$ is a basis function for the test function space,
   * \f$ \phi_s \f$ is a basis function for the unk function space,
   * \f$ \alpha \f$ and \f$ \beta \f$ are multiindices that specify the
   * differentiation order and direction on the test and unk basis functions,
   * respectively, and \f$ f(x) \f$ is a coefficient function. If the integral
   * is to be done with quadrature, then one must also provide
   * a quadrature rule. A WeakForm object contains a unique
   * combination of basis families, multiindices,
   * coefficient function, and quadrature rule; all terms using that
   * combination are evaluated using that WeakForm.
   *
   * Several terms in a problem might share a common WeakForm but have
   * different function ID numbers or constant coefficents, and they
   * might contribute to different blocks in a block operator. For example,
   * in a Navier-Stokes problem the x and y components of velocity will have
   * the same basis functions, and the diffusion operator will be applied
   * in the same way to both. Thus, all velocity diffusion terms in a
   * Navier-Stokes problem can be represented with a common set of WeakForms.
   *
   *
   */

  class WeakForm
    {
    public:
      /** empty ctor for use in container classes */
      WeakForm();

      /** ctor for two-forms */
      WeakForm(EquationSet* eqnSet, int blockRow, int blockCol,
               const Expr& coeff,
               const Expr& var, const Expr& unk,
               const QuadratureFamily& quad, bool isBC);
      /** ctor for one-forms */
      WeakForm(EquationSet* eqnSet, int blockRow,
               const Expr& coeff, const Expr& var,
               const QuadratureFamily& quad, bool isBC);

      /** return the quadrature family common to all terms in this WeakForm */
      const QuadratureFamily& quad() const {return quad_;}

      /** return the coefficient function
       * common to all terms in this WeakForm */
      const Expr& coeff() const {return coeff_;}

      /** return the test function basis family common to all terms
       * in this WeakForm */
      const BasisFamily& test() const {return test_;}

      /** return the unk function basis family common to all terms
       * in this WeakForm */
      const BasisFamily& unk() const {return unk_;}

      /** return the multi-index used for all test functions in this weak
       * form */
      const MultiIndex& miTest() const {return miTest_;}

      /** return the multi-index used for all unk functions in this weak
       * form */
      const MultiIndex& miUnk() const {return miUnk_;}

      /** indicate whether this weak form has any terms in the
          given block */
      bool usesBlock(int blockRow, int blockCol) const ;

      /** indicate whether this weak form has any terms in the
          given block */
      bool usesBlock(int blockRow) const ;

      /**  get the list of testIDs for the given (blockRow, blockCol) */
      const TSFArray<int>& testIDList(int blockRow,
                                      int blockCol) const ;

      /**  get the list of unkIDs for the given (blockRow, blockCol) */
      const TSFArray<int>& unkIDList(int blockRow,
                                     int blockCol) const ;

      /** get the list of testIDs for the current block row. This
       *  should be used for one-forms only */
      const TSFArray<int>& testIDList(int blockRow) const ;

      /** get the list of constant coefficients
       * in the (blockRow, blockCol) subblock */
      const TSFArray<double>& termCoeff(int blockRow, int blockCol) const ;

      /** get the constant coefficients
       * in the blockRow-th subblock (one-forms only) */
      const TSFArray<double>& termCoeff(int blockCol) const ;

      /** get transposition flags for the (blockRow, blockCol) block */
      const TSFArray<bool>& isTransposed(int blockRow, int blockCol) const ;

      /** get the BC flags for the blockRow-th subblock */
      const TSFArray<bool>& isEssentialBC(int blockRow) const ;

      /** get the BC flags for the (blockRow, blockCol) block */
      const TSFArray<bool>& isEssentialBC(int blockRow, int blockCol ) const ;

      /** indicate whether this weakform is a one-form */
      bool isOneForm() const {return isOneForm_;}

      /** indicate whether this weakform is symmetric, that is, has the
       * same basis and multiindex for both test and unk function */
      bool isSymmetric() const {return isSymmetric_;}

      /** try to append a term with the given signature to the weak form.
       * If the term matches, return true, otherwise return false. */
      bool tryAppend(int blockRow, int blockCol,
                     const Expr& coeff, const Expr& var,
                     const Expr& unk, bool isBC);

      /** try to append a term with the given signature to the weak form.
       * If the term matches, return true, otherwise return false. */
      bool tryAppend(int blockRow, const Expr& coeff, const Expr& var,
                     bool isBC);

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

    private:
      /** method to do common ctor operations */
      void init(int blockRow, int blockCol,
                const Expr& var, const Expr& unk, bool isBC);

      /** unmanaged reverse pointer to the equation set that owns
       * this WeakForm */
      EquationSet* eqnSet_;


      /** \name Data that is common to all terms and blocks */
      //@{
      QuadratureFamily quad_;
      Expr coeff_;
      BasisFamily test_;
      BasisFamily unk_;
      MultiIndex miTest_;
      MultiIndex miUnk_;
      bool isOneForm_;
      bool isSymmetric_;
      //@}

      /** \name Data that is specific to a given (block, term) combination */
      //@{
      TSFArray<TSFArray<TSFArray<double> > > termCoeffs_;
      TSFArray<TSFArray<TSFArray<int> > > testID_;
      TSFArray<TSFArray<TSFArray<int> > > unkID_;
      TSFArray<TSFArray<TSFArray<bool> > > isTransposed_;
      TSFArray<TSFArray<TSFArray<bool> > > isEssentialBC_;
      //@}

      /** \name flags indicating whether a given block is nonzero */
      //@{
      TSFArray<TSFArray<bool> > isNonzero_;
      //@}
    };

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


}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by