---

StaticLinearProblem.h

Go to the documentation of this file.

#ifndef STATICLINEARPROBLEM_H
#define STATICLINEARPROBLEM_H

#include "SundanceDefs.h"
#include "DistributedMatrixBuilder.h"
#include "TSFMatrixOperator.h"
#include "TSFMultiVectorOperator.h"
#include "TSFLinearProblemBase.h"
#include "TSFLinearSolver.h"
#include "TSFSmartPtr.h"
#include "Block.h"
#include "DirectSolver.h"
#include "Defaults.h"
#include "TSFTimeMonitor.h"


namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  /** \ingroup UserLevelFE
   * StaticLinearProblem combines a mesh and a variational expression
   * into an object that can build a matrix.
   */

  class StaticLinearProblem : public TSFLinearProblemBase
    {
    public:
      /** */
      StaticLinearProblem();
      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const EssentialBC& bc,
                          const Expr& var,
                          const Expr& unk,
                          const TSFVectorType& vt = Defaults::vectorType());
      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const Expr& var,
                          const Expr& unk,
                          const TSFVectorType& vt = Defaults::vectorType());

      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const Expr& var,
                          const TSFVectorType& vt = Defaults::vectorType());

      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const TSFArray<Block>& varBlocks,
                          const TSFArray<Block>& unkBlocks);
      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const TSFArray<Block>& varBlocks);

      /** */
      StaticLinearProblem(const Mesh& mesh,
                          const Expr& integral,
                          const EssentialBC& bc,
                          const TSFArray<Block>& varBlocks,
                          const TSFArray<Block>& unkBlocks);
      /** */
      virtual ~StaticLinearProblem(){;}

      /** */
      Expr formSolnExpr(const TSFVector& x) const ;

      /** */
      Expr formSolnExpr(const TSFArray<TSFVector>& x) const ;

      /** */
      virtual TSFVector getRHS() const ;

      /** */
      //      virtual void fillRHS(TSFVector& rhs) const ;

      /** */
      virtual TSFVector getRHS(const TSFVectorSpace& space) const ;

      /** */
      virtual TSFLinearOperator getOperator() const ;

      /** */
      Expr solve(const TSFLinearSolver& solver = new DirectSolver()) const ;

      /** */
      Expr getRHSExpr() const ;

      /** */
      void flushMatrixValues() {matrixNeedsBuilding_=true; vectorNeedsBuilding_=true;}
      void flushVectorValues() {vectorNeedsBuilding_=true;}
      void flushMatrixConfiguration() {builder_->flushConfiguration();}

      /** */
      void printRowMaps() const {builder_->printRowMaps();}

      /** */
      void printColumnMaps() const {builder_->printColumnMaps();}

      /** */
      void showGraph(ostream& os) const {builder_->showGraph(os);}

      /** */
      void showBCRows(ostream& os) const {builder_->showBCRows(os);}

      /** */
      int numBlocks() const {return vectorBlocks_.length();}

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

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

    private:
      /** initialization steps common to all ctors */
      void init(const Mesh& mesh,
                const Expr& integral,
                const EssentialBC& bc,
                const TSFArray<Block>& varBlocks,
                const TSFArray<Block>& unkBlocks);

      Expr integral_;
      EssentialBC bc_;

      TSFSmartPtr<DistributedMatrixBuilder> builder_;

      mutable TSFLinearOperator op_;

      mutable TSFVector rhs_;

      mutable TSFArray<TSFArray<TSFMatrixOperator*> > matrixBlocks_;

      mutable TSFArray<TSFArray<TSFMultiVectorOperator*> > multiVectorBlocks_;

      mutable TSFArray<TSFVector> vectorBlocks_;

      mutable bool matrixNeedsBuilding_;

      mutable bool vectorNeedsBuilding_;

      mutable bool graphNeedsBuilding_;

      static TSFTimer& solveTimer();

      static TSFTimer& initTimer();

      static TSFTimer& rhsTimer();

      static TSFTimer& opTimer();
    };





}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by