TPZLagrangeMultiplier.h

Go to the documentation of this file.

//
//  TPZLagrangeMultiplier.h
//  PZ
//
//  Created by Philippe Devloo on 5/2/14.
//
//

#ifndef __PZ__TPZLagrangeMultiplier__
#define __PZ__TPZLagrangeMultiplier__

#include <iostream>
#include "pzdiscgal.h"

class TPZLagrangeMultiplier : public TPZDiscontinuousGalerkin
{
    
    int fNStateVariables;
    
    int fDimension;
    
    STATE fMultiplier;
    
    public :
                TPZLagrangeMultiplier() : TPZRegisterClassId(&TPZLagrangeMultiplier::ClassId),
    TPZDiscontinuousGalerkin()
    {
        
    }
                TPZLagrangeMultiplier(int nummat, int dimension, int nstate) : TPZRegisterClassId(&TPZLagrangeMultiplier::ClassId),
    TPZDiscontinuousGalerkin(nummat), fNStateVariables(nstate), fDimension(dimension), fMultiplier(1.)
    {
        
    }
                
                TPZLagrangeMultiplier(const TPZLagrangeMultiplier &copy) : TPZRegisterClassId(&TPZLagrangeMultiplier::ClassId),
    TPZDiscontinuousGalerkin(copy), fNStateVariables(copy.fNStateVariables), fDimension(copy.fDimension), fMultiplier(copy.fMultiplier)
    {
        
    }
    
    TPZLagrangeMultiplier &operator=(const TPZLagrangeMultiplier &copy)
    {
        TPZDiscontinuousGalerkin::operator=(copy);
        fNStateVariables = copy.fNStateVariables;
        fDimension = copy.fDimension;
        fMultiplier = copy.fMultiplier;
        return *this;
    }
    
    TPZMaterial *NewMaterial() override
    {
        return new TPZLagrangeMultiplier(*this);
    }
    
                virtual ~TPZLagrangeMultiplier()
    {
        
    }
    
    virtual int Dimension() const override
    {
        return fDimension;
    }
    
    virtual void SetMultiplier(STATE mult)
    {
        fMultiplier = mult;
    }
    
                
                virtual std::string Name() override
    {
        return "TPZLagrangeMultiplier";
    }
                
                virtual void FillDataRequirementsInterface(TPZMaterialData &data) override
    {
        data.SetAllRequirements(false);
    }
    
    virtual void FillDataRequirementsInterface(TPZMaterialData &data, TPZVec<TPZMaterialData > &datavec_left, TPZVec<TPZMaterialData > &datavec_right) override
    {
        data.SetAllRequirements(false);
//        data.fNeedsNormal = true;
        int nref_left = datavec_left.size();
        for(int iref = 0; iref<nref_left; iref++){
            datavec_left[iref].SetAllRequirements(false);
//            datavec_left[iref].fNeedsSol    = true;
//            datavec_left[iref].fNeedsNormal = true;
        }
        int nref_right = datavec_right.size();
        for(int iref = 0; iref<nref_right; iref++){
            datavec_right[iref].SetAllRequirements(false);
//            datavec_right[iref].fNeedsSol    = true;
//            datavec_right[iref].fNeedsNormal = true;
        }
        
    }
                
    virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override
    {
        DebugStop();
    }
    
    virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override
    {
        DebugStop();
    }
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc)  override {
        DebugStop();
    }
    
                virtual void Contribute(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ef)  override {
                                DebugStop();
                }
                virtual void ContributeBC(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override {
                                DebugStop();
                }
    
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    
//    virtual void ContributeInterface(TPZVec<TPZMaterialData> &datavec, TPZVec<TPZMaterialData> &dataleftvec, TPZVec<TPZMaterialData> &datarightvec,
//                                     REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef)
//    {
//        DebugStop();
//    }
                
    virtual void ContributeInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, TPZVec<TPZMaterialData> &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
                
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ef) override;
                
    
                virtual void ContributeInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, TPZVec<TPZMaterialData> &dataright, REAL weight, TPZFMatrix<STATE> &ef) override
    {
        ContributeInterface(data, dataleft[0], dataright[0], weight, ef);
    }
                
    
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override
    {
        DebugStop();
    }
    
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override
    {
        DebugStop();
    }
    
                
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc) override
    {
        DebugStop();
    }
                
    void SolutionDisc(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, int var, TPZVec<STATE> &Solout)
    {
        std::cout << __PRETTY_FUNCTION__ << " should never be called\n";
        DebugStop();
    }
                
                virtual void InterfaceJump(TPZVec<REAL> &x, TPZSolVec &leftu,TPZSolVec &rightu,TPZSolVec &jump) override
    {
        DebugStop();
    }
                
                
                
                virtual int NStateVariables() const override
    {
        return fNStateVariables;
    }
                
                
                virtual void ContributeInterfaceErrors(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright,
                                                                                                                                                                   REAL weight,
                                                                                                                                                                   TPZVec<STATE> &nkL,
                                                                                                                                                                   TPZVec<STATE> &nkR,
                                                                                                                                                                   int &errorid)  override {
                                PZError << "Method not implemented\n";
                }
                
                virtual void ContributeInterfaceBCErrors(TPZMaterialData &data, TPZMaterialData &dataleft,
                                                                                                                                                                                 REAL weight,
                                                                                                                                                                                 TPZVec<STATE> &nk,
                                                                                                                                                                                 TPZBndCond &bc,
                                                                                                                                                                                 int &errorid)  override {
                                PZError << "Method not implemented\n";
                }
                
                public:
virtual int ClassId() const override;

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

#endif /* defined(__PZ__TPZLagrangeMultiplier__) */