FEFunction3D.h

// =======================================================================
// %W% %G%
// 
// Class:       TFEFunction3D
// Purpose:     a function from a finite element space in 3D
//
// Author:      Gunar Matthies (17.01.98)
//
// History:     start of implementation 17.01.98 (Gunar Matthies)
//
//              start of reimplementation 06.08.1998 (GM)
//
// =======================================================================

#ifndef __FEFUNCTION3D__
#define __FEFUNCTION3D__

#include <AllClasses.h>
#include <FESpace3D.h>
#include <AuxParam3D.h>
#include <Constants.h>
#include <vector>

class TFEFunction3D
{
  protected:
    char *Name;

    char *Description;

    TFESpace3D *FESpace3D;

    double *Values;

    int Length;

  public:
    TFEFunction3D(TFESpace3D *fespace3D, char *name, char *description,
                  double *values, int length);

    ~TFEFunction3D();

    char *GetName()
    { return Name; }

    char *GetDescription()
    { return Description; }

    TFESpace3D *GetFESpace3D()
    { return FESpace3D; }

    int GetLength()
    { return Length; }

    double *GetValues()
    { return Values; }

    void GetErrors(DoubleFunct3D *Exact, int N_Derivatives,
                   MultiIndex3D *NeededDerivatives,
                   int N_Errors, ErrorMethod3D *ErrorMeth, 
                   CoeffFct3D *Coeff, TAuxParam3D *Aux,
                   int n_fespaces, TFESpace3D **fespaces,
                   double *errors);
    
    void GetErrorsForVectorValuedFunction(DoubleFunct3D ** const Exact,
                                          ErrorMethod3D * const ErrMeth,
                                          double * const errors);
    
    void GetErrorsAdapt(DoubleFunct3D *Exact, int N_Derivatives,
            MultiIndex3D *NeededDerivatives,
            int N_Errors, ErrorMethod3D *ErrorMeth, 
            CoeffFct3D *Coeff, 
            TAuxParam3D *Aux,
            int n_fespaces, TFESpace3D **fespaces,
            double *errors);
    
    void GetErrorsOPTPDE(DoubleFunct3D *Exact, int N_Derivatives,
           MultiIndex3D *NeededDerivatives,
           int N_Errors, ErrorMethod3D *ErrorMeth, 
           CoeffFct3D *Coeff, TAuxParam3D *Aux,
           int n_fespaces, TFESpace3D **fespaces,
           double radius, double upper, double lower, double *errors);
    

    void GetMeshCellParams(DoubleFunct3D *Exact, int N_Derivatives,
                   MultiIndex3D *NeededDerivatives,
                   int N_Errors, ErrorMethod3D *ErrorMeth, 
                   CoeffFct3D *Coeff, TAuxParam3D *Aux,
                   int n_fespaces, TFESpace3D **fespaces,
                   double *errors, double *cell_parameters);

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

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

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

    void Interpolate(DoubleFunct3D *Exact);

    void InterpolateSuper(DoubleFunct3D *Exact);
    
    void Interpolate(int N_Coord, double *Coords, int N_AuxFeFcts, 
                     TFEFunction3D **AuxFeFcts, DoubleFunctND *Exact);
    
    void Interpolate_vector_valued_function(std::vector<DoubleFunct3D*> Exact);
    
    void project_into_L20(double a = 0.0);

    void compute_integral_and_measure(double& integral, double& measure) const;

    void SetDirichletBC(BoundCondFunct3D *BoundaryCondition,
                                   BoundValueFunct3D *BoudaryValue);
    
   void MinMax(double & min, double & max);

   void PrintMinMax();
};

#endif