FEFunction2D.h

// =======================================================================
// @(#)FEFunction2D.h        1.3 04/13/00
// 
// Class:       TFEFunction2D
// Purpose:     a function from a finite element space in 2D
//
// Author:      Gunar Matthies (17.01.98)
//
// History:     start of implementation 17.01.98 (Gunar Matthies)
//
//              start of reimplementation 06.08.1998 (GM)
//
// =======================================================================

#ifndef __FEFUNCTION2D__
#define __FEFUNCTION2D__

#include <AllClasses.h>
#include <FESpace2D.h>
#include <AuxParam2D.h>
#include <Constants.h>

class TFEFunction2D
{
  protected:
    char *Name;

    char *Description;

    TFESpace2D *FESpace2D;

    double *Values;

    int Length;

  public:
    TFEFunction2D(TFESpace2D *fespace2D, char *name, char *description,
                  double *values, int length);

    ~TFEFunction2D();

    char *GetName()
    { return Name; }

    char *GetDescription()
    { return Description; }

    TFESpace2D *GetFESpace2D()
    { return FESpace2D; }

    int GetLength()
    { return Length; }

    double *GetValues()
    { return Values; }

    void GetErrors(DoubleFunct2D *Exact, int N_Derivatives,
                   MultiIndex2D *NeededDerivatives,
                   int N_Errors, ErrorMethod2D *ErrorMeth, 
                   CoeffFct2D *Coeff, TAuxParam2D *Aux,
                   int n_fespaces, TFESpace2D **fespaces,
                   double *errors);

    void  GetErrorsForVectorValuedFunction(
                  DoubleFunct2D * const * const Exact, 
                  ErrorMethod2D * const ErrorMeth, 
                  double * const errors);
    
    void GetErrorsAdapt(DoubleFunct2D *Exact, int N_Derivatives,
           MultiIndex2D *NeededDerivatives,
           int N_Errors, ErrorMethod2D *ErrorMeth, 
           CoeffFct2D *Coeff, TAuxParam2D *Aux,
           int n_fespaces, TFESpace2D **fespaces,
           double *errors);
    
    void GetErrorsOPTPDE(DoubleFunct2D *Exact, int N_Derivatives,
           MultiIndex2D *NeededDerivatives,
           int N_Errors, ErrorMethod2D *ErrorMeth, 
           CoeffFct2D *Coeff, TAuxParam2D *Aux,
           int n_fespaces, TFESpace2D **fespaces,
           int& kink, double upper, double lower, double *errors);
    
    void GetErrorsAdaptOPTPDE(DoubleFunct2D *Exact, int N_Derivatives,
            MultiIndex2D *NeededDerivatives,
            int N_Errors, ErrorMethod2D *ErrorMeth, 
            CoeffFct2D *Coeff, TAuxParam2D *Aux,
            int n_fespaces, TFESpace2D **fespaces,
            double radius, double upper, double lower,double *errors);

    void FindGradient(double x, double y, double *values);

    void FindGradientLocal(TBaseCell *cell, int cell_no, double x, double y, double *values);

    void FindValueLocal(TBaseCell *cell, int cell_no, double x, double y, double *values);

    void Interpolate(DoubleFunct2D *Exact);
    void Interpolate(TFEFunction2D *F);
    
    void project_into_L20(double a = 0.0);
    
    void compute_integral_and_measure(double& integral, double& measure) const;
    
    double compute_mean() const;    

    void GetMeshCellParams(DoubleFunct2D *Exact, int N_Derivatives,
                           MultiIndex2D *NeededDerivatives,
                           int N_Errors, ErrorMethod2D *ErrorMeth, 
                           CoeffFct2D *Coeff, 
                           TAuxParam2D *Aux,
                           int n_fespaces, TFESpace2D **fespaces,
                           double *errors, double *parameters);

    void InterpolateSuper(DoubleFunct2D *Exact);
    
    void SetDirichletBC(BoundCondFunct2D *BoundaryCondition,
                        BoundValueFunct2D *BoundaryValue);
    
   void WriteSol();

   void ReadSol(char *BaseName);
   

   void CorrectMass(double OldMass);

   void GetMassAndMean(double *OutVal);
   
   
   TFEFunction2D& operator*=(double alpha);
   
   TFEFunction2D & operator+=(const TFEFunction2D & rhs);
   
   TFEFunction2D & operator=(const TFEFunction2D & rhs);
   void MinMax(double & min, double & max);

   void PrintMinMax();

};
#endif