---

DiscreteFunction.h

Go to the documentation of this file.

#ifndef DISCRETEFUNCTION_H
#define DISCRETEFUNCTION_H

#include "SundanceDefs.h"

#include "TSFSmartPtr.h"
#include "FuncExprBase.h"
#include "DenseSerialVector.h"
#include "TSFRBTree.h"
#include "BasisFamily.h"
#include "SundanceVectorSpace.h"
#include "DistributedDOFMap.h"
#include "TSFTimeMonitor.h"
#include "TSFVector.h"
#include "TSFNonDupArray.h"

namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;

  /**
   * \ingroup UserLevelSymbolics
   * Symbolic representation of a discrete solution of a finite-element problem.
   */

  class DiscreteFunction : public FuncExprBase
    {
    public:
      /** \name User-level methods */
      //@{
      /** Discretize an expression on a mesh, using the given basis */
      DiscreteFunction(const TSFVectorSpace& space,
                       const Expr& expr,
                       const string& name="");

      static Expr discretize(const TSFVectorSpace& space, const Expr& expr,
                             const string& name="");
      //@}

      /** \name Developer-only methods */
      //@{
      /** Build a component of a discrete function from a vector and vector map.
       *  This is used when building a solution expr from the solution of
       * a numerical linear algebra problem
       */
      DiscreteFunction(const AbstractFunctionSpace& abstractSpace,
                       const TSFVector& vector, int myReducedIndex,
                       const string& name="");
      /** */
      virtual ~DiscreteFunction(){;}

      /** */
      virtual void evaluate(const WorkSet& workSet,
                            const QuadratureFamily& quadFamily,
                            DenseSerialVector& result) const ;

      /** */
      virtual void evaluate(const AbstractFunctionSpace& targetSpace,
                            const TSFArray<Cell>& cells,
                            const TSFArray<int>& cellIndices,
                            const TSFArray<int>& dofIndices,
                            const TSFArray<Point>& x,
                            DenseSerialVector& values) const ;

      /** probe value at a point */
      virtual double probeAtMeshPoint(int localPointIndex) const ;

      /** */
      virtual double norm() const ;
      /** */
      virtual double quickNorm() const ;
      /** */
      virtual double maxNorm() const ;
      /** */
      virtual void getVector(TSFVector& vector) const ;

      /** */
      virtual void setVector(const TSFVector& vector) ;
      /** */
      virtual void readValues(const string& filename);

      /** */
      virtual ExprValue average(const Cell& cell) const ;

      // differentiation
      /** */
      virtual void derivative(const MultiIndex& d, Expr& result) const ;

      /** */
      virtual const MultiIndex& multiIndex() const {return ExprBase::dummyMultiIndex_;}

      // ordering and RTTI
      /** */
      virtual bool operator==(const Expr& other) const ;
      /** */
      virtual bool operator<(const Expr& other) const ;
      /** */
      virtual int sortPriority() const {return DISCRETEFUNCTION;}
      /** */
      virtual bool isDiscreteFunction() const {return true;}

      // misc
      /** */
      virtual ExprBase* clone() const ;
      /** */
      virtual void print(ostream& os, bool paren=false) const ;
      /** */
      virtual string toString(bool paren=false) const ;

      // FE support
      virtual void getBasis(BasisFamily& basis) const {basis = getBasis();}

      virtual bool getMesh(Mesh& mesh) const {mesh = abstractSpace_.mesh(); return true;}

      /** return the DOF map associated with a discrete function */
      virtual void getDOFMap(TSFSmartPtr<DOFMapBase>& m) const
        {m = abstractSpace_.map();}

      /** return the index of a discrete function into a list */
      virtual int getReducedIndex() const {return myReducedIndex_;}

      /** get the cell sets on which this function is defined */
      virtual void getDomain(TSFNonDupArray<CellSet>& domain) const
        {domain = abstractSpace_.domains(myReducedIndex_);}

      /** */
      virtual void matlabDump(ostream& os) const ;

      /** */
      virtual void fullForm(ostream& os) const ;

      /** */
      virtual XMLObject toXML() const ;

      void checkEvaluationCells(const TSFArray<Cell>& cells, int nCells) const ;

      static bool& paranoidChecking() {static bool rtn = false; return rtn;}

      //@}
      friend class DiscreteFunctionDeriv;


    private:

      const BasisFamily& getBasis() const
        {return abstractSpace_.basis(myReducedIndex_);}

      const TSFSmartPtr<DOFMapBase>& map() const
        {return abstractSpace_.map();}

      /* */
      AbstractFunctionSpace abstractSpace_;

      /* */
      CellSet domain_;

      /* */
      TSFVector vector_;

      /* */
      int myReducedIndex_;

      static TSFTimer& discretizeTimer();
    };

}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by