TPZMaterial.h

Go to the documentation of this file.

#ifndef PZMATERIALHPP
#define PZMATERIALHPP

#include "pzreal.h"
#include "pzvec.h"
#include "pzmatrix.h"
#include "pzfmatrix.h"
#include "pzadmchunk.h"
#include "tpzautopointer.h"
#include "TPZSavable.h"
#include "pzmaterialdata.h"
#include "pzfunction.h"
#include "pzcompel.h"

#include <iostream>
#include <string>

class TPZBndCond;
class TPZMaterial;
class TPZMaterialData;
class TPZIntPoints;

class  TPZMaterial : public virtual TPZSavable
{
private:
    int fId;
    
protected:
   
    TPZAutoPointer<TPZFunction<STATE> > fForcingFunction;
                
    TPZAutoPointer<TPZFunction<STATE> > fForcingFunctionExact;
                
    TPZAutoPointer<TPZFunction<STATE> > fTimeDependentForcingFunction;
                
    TPZAutoPointer<TPZFunction<STATE> > fTimedependentFunctionExact;
    
    TPZAutoPointer<TPZFunction<STATE> > fBCForcingFunction;
    
    TPZAutoPointer<TPZFunction<STATE> > fTimedependentBCForcingFunction;    
    

    bool fLinearContext;
    int fNumLoadCases;
    
    int fPostProcIndex;
    
public:
    static REAL gBigNumber;
    
    TPZMaterial(int id);
    
    TPZMaterial();
    
    TPZMaterial(const TPZMaterial &mat);
    
    TPZMaterial &operator=(const TPZMaterial &copy);
    
    virtual ~TPZMaterial();
    
    virtual void FillDataRequirements(TPZMaterialData &data);
                
                virtual void FillDataRequirements(TPZVec<TPZMaterialData > &datavec);
    
    virtual void FillBoundaryConditionDataRequirement(int type,TPZMaterialData &data)
    {
        // default is no specific data requirements
        if(type == 50)
        {
            data.fNeedsSol = true;
        }
    }
    
    virtual void FillBoundaryConditionDataRequirement(int type,TPZVec<TPZMaterialData > &datavec)
    {
        // default is no specific data requirements
        int nref = datavec.size();
        if(type == 50)
        {
            for(int iref = 0; iref<nref; iref++){
                datavec[iref].fNeedsSol = true;
            }
        }
    }

    virtual void FillDataRequirementsInterface(TPZMaterialData &data)
    {
        data.fNeedsNormal = false;
    }
    
    virtual void FillDataRequirementsInterface(TPZMaterialData &data, TPZVec<TPZMaterialData > &datavec_left, TPZVec<TPZMaterialData > &datavec_right)
    {
        data.SetAllRequirements(false);
        int nref_left = datavec_left.size();
        for(int iref = 0; iref<nref_left; iref++){
            datavec_left[iref].SetAllRequirements(false);
        }
        int nref_right = datavec_right.size();
        for(int iref = 0; iref<nref_right; iref++){
            datavec_right[iref].SetAllRequirements(false);
        }

    }
    
    
    virtual std::string Name() { return "no_name"; }
    
    virtual int Dimension() const = 0;
    
    int Id() const { return fId; }
    void SetId(int id) {
/*        if(id == 0) {
            std::cout << "\n*** Material Id can't be ZERO! ***\n";
            std::cout << "*** This Will Be a Disaster!!! ***\n";
            DebugStop();
        }*/
        fId = id; }
    
    virtual int NStateVariables() const = 0;
    
    virtual int NFluxes() {return 0;}
    
    int NumLoadCases()
    {
        return fNumLoadCases;
    }
    
    virtual int MinimumNumberofLoadCases()
    {
        return 1;
    }
    
    void SetNumLoadCases(int numloadcases)
    {
        if(numloadcases <= 0)
        {
            std::cout << __PRETTY_FUNCTION__ << " numloadcases " << numloadcases << " cannot be less or equal to zero\n";
            DebugStop();
        }
        fNumLoadCases = numloadcases;
    }
    
    void SetPostProcessIndex(int index)
    {
#ifdef PZDEBUG
        if (index < 0 || index >= fNumLoadCases)
        {
            DebugStop();
        }
#endif
        fPostProcIndex = index;
    }
                
    virtual void Print(std::ostream &out = std::cout);
    
    virtual int VariableIndex(const std::string &name);
    
    virtual int NSolutionVariables(int var);
    
    virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout);
                
    virtual void Solution(TPZVec<TPZMaterialData> &datavec, int var, TPZVec<STATE> &Solout);
                
    virtual void Solution(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleftvec, TPZVec<TPZMaterialData> &datarightvec, int var, TPZVec<STATE> &Solout);
                
    virtual void Solution(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleftvec, TPZVec<TPZMaterialData> &datarightvec, int var, TPZVec<STATE> &Solout, TPZCompEl * left, TPZCompEl * ritgh);             
    
protected:
    virtual void Solution(TPZVec<STATE> &Sol,TPZFMatrix<STATE> &DSol,TPZFMatrix<REAL> &axes,int var,TPZVec<STATE> &Solout);
    
public:
    
    virtual void Flux(TPZVec<REAL> &x, TPZVec<STATE> &Sol,
                      TPZFMatrix<STATE> &DSol, TPZFMatrix<REAL> &axes,
                      TPZVec<STATE> &flux) {}
    
    virtual TPZBndCond *CreateBC(TPZMaterial *reference, int id, int typ, TPZFMatrix<STATE> &val1,
                                 TPZFMatrix<STATE> &val2);
    
    virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) = 0;
    
    virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ef);
    

    virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef);
                
    virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ef)
    {
        TPZFMatrix<STATE> ek(ef.Rows(),ef.Rows(),0.);
        Contribute(datavec, weight, ek, ef);
    }
    
    virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) = 0;
                
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ef, TPZBndCond &bc)
    {
        TPZFMatrix<STATE> ek(ef.Rows(),ef.Rows(),0.);
        ContributeBC(datavec, weight, ek, ef, bc);
        
    }
    
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc);

    virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ef, TPZBndCond &bc);
                
    void SetForcingFunction(TPZAutoPointer<TPZFunction<STATE> > fp)
    {
                                                fForcingFunction = fp;
    }
    void SetForcingFunction(void (*fp)(const TPZVec<REAL> &loc, TPZVec<STATE> &result), int porder )
                                {
                                                                if(fp)
                {
                    TPZDummyFunction<STATE> *loc = new TPZDummyFunction<STATE>(fp, porder);
                    loc->SetPolynomialOrder(porder);
                    fForcingFunction = loc;
                }
            
                                                                else fForcingFunction = NULL;
                                }
    
    void SetForcingFunction(void (*fp)(const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &gradu), int porder )
    {
        if(fp)
        {
            TPZDummyFunction<STATE> *loc = new TPZDummyFunction<STATE>(fp, porder);
            loc->SetPolynomialOrder(porder);
            fForcingFunction = loc;
        }
        
        else fForcingFunction = NULL;
    }

                TPZAutoPointer<TPZFunction<STATE> > &ForcingFunction() {
                                return fForcingFunction;
                }
                
                void SetForcingFunctionExact(TPZAutoPointer<TPZFunction<STATE> > fp)
                {
                                fForcingFunctionExact = fp;
                }
                
    TPZAutoPointer<TPZFunction<STATE> > &ForcingFunctionExact() {
        return fForcingFunctionExact;
    }
    
    void SetTimeDependentForcingFunction(TPZAutoPointer<TPZFunction<STATE> > fp)
    {
                                fTimeDependentForcingFunction = fp;
    }
                
    TPZAutoPointer<TPZFunction<STATE> > &TimeDependentForcingFunction() {
        return fTimeDependentForcingFunction;
    }
    
                void SetTimeDependentFunctionExact(TPZAutoPointer<TPZFunction<STATE> > fp)
                {
                                fTimedependentFunctionExact = fp;
                }
    
    TPZAutoPointer<TPZFunction<STATE> > &TimedependentFunctionExact() {
        return fTimedependentFunctionExact;
    }
                
    void SetBCForcingFunction(TPZAutoPointer<TPZFunction<STATE> > fp)
    {
        fBCForcingFunction = fp;
    }
    
    TPZAutoPointer<TPZFunction<STATE> > &BCForcingFunction() {
        return fBCForcingFunction;
    }
    
    void SetTimedependentBCForcingFunction(TPZAutoPointer<TPZFunction<STATE> > fp)
    {
        fTimedependentBCForcingFunction = fp;
    }
    
    TPZAutoPointer<TPZFunction<STATE> > &TimedependentBCForcingFunction() {
        return fTimedependentBCForcingFunction;
    }
    
    virtual int HasForcingFunction() {return (fForcingFunction != 0);}
    
                virtual int HasForcingFunctionExact() {return (fForcingFunctionExact != 0);}
    
    virtual int HasBCForcingFunction() {return (fBCForcingFunction != 0);}
    
    virtual int HasTimedependentFunctionExact() {return (fTimedependentFunctionExact != 0);}
    
    virtual int HasTimedependentForcingFunction() {return (fTimeDependentForcingFunction != 0);}
    
    virtual int HasTimedependentBCForcingFunction() {return (fTimedependentBCForcingFunction != 0);}
    
    
    virtual int IntegrationRuleOrder(int elPMaxOrder) const;
                
    virtual int IntegrationRuleOrder(TPZVec<int> &elPMaxOrder) const;
                
    virtual void Errors(TPZMaterialData &data, TPZVec<STATE> &u_exact, TPZFMatrix<STATE> &du_exact, TPZVec<REAL> &errors)
    {
        TPZManVector<STATE,3> flux;
        Flux(data.x, data.sol[0], data.dsol[0], data.axes, flux);
        Errors(data.x, data.sol[0], data.dsol[0], data.axes, flux, u_exact, du_exact, errors );
    }
    virtual void Errors(TPZVec<TPZMaterialData> &data, TPZVec<STATE> &u_exact, TPZFMatrix<STATE> &du_exact, TPZVec<REAL> &errors)
    {
        DebugStop();
    }

    virtual void Errors(TPZVec<REAL> &x, TPZVec<STATE> &sol, TPZFMatrix<STATE> &dsol,
                        TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux,
                        TPZVec<STATE> &uexact, TPZFMatrix<STATE> &duexact,
                        TPZVec<REAL> &val) {
        PZError << __PRETTY_FUNCTION__ << std::endl;
        PZError << "Method not implemented! Error comparison not available. Please, implement it." << std::endl;
    }
                virtual         void ErrorsHdiv(TPZMaterialData &data, TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values) {
                                PZError << __PRETTY_FUNCTION__ << std::endl;
                                PZError << "Nao sei o q fazer." << std::endl;
                                
                }
    virtual int NEvalErrors() {return 3;}
    
    virtual TPZMaterial * NewMaterial();
    
    virtual void SetData(std::istream &data);
    
    virtual void Clone(std::map<int, TPZMaterial * > &matvec);
    
    virtual int FluxType() { return 2; }
                
    virtual void ContributeErrors(TPZMaterialData &data,
                                  REAL weight,
                                  TPZVec<REAL> &nk,
                                  int &errorid){
        PZError << "Error at " << __PRETTY_FUNCTION__ << " - Method not implemented\n";
    }
    
    virtual REAL ComputeSquareResidual(TPZVec<REAL>& X, TPZVec<STATE> &sol, TPZFMatrix<STATE> &dsol){
        PZError << "Error at " << __PRETTY_FUNCTION__ << " - Method not implemented\n";
        return -1.;
    }
    
    virtual int PushMemItem(int sourceIndex = -1){ return -1; }
    
    virtual void FreeMemItem(int index){ return; }
    
    void SetLinearContext(bool IsLinear);
    
    bool GetLinearContext() const {
        return fLinearContext;
    }
    
    public:
int ClassId() const override;

    
    void Write(TPZStream &buf, int withclassid) const override;
    
    void Read(TPZStream &buf, void *context) override;
    
};

extern TPZVec< void(*) (const TPZVec<REAL> &, TPZVec<STATE>& ) > GFORCINGVEC;

#endif