pztransientmat.cpp

Go to the documentation of this file.

#include "pztransientmat.h"

template<class TBASEMAT>
int TPZTransientMaterial<TBASEMAT>::ClassId() const{
    return Hash("TPZTransientMaterial") ^ TBASEMAT::ClassId() << 1;
}
template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::SetExplicit() {
                this->fTemporalIntegrator = EExplicit;
}
template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::SetImplicit() {
                this->fTemporalIntegrator = EImplicit;
}

template<class TBASEMAT>
TPZTransientMaterial< TBASEMAT >::TPZTransientMaterial(int nummat, int dim, REAL TimeStep):TPZRegisterClassId(&TPZTransientMaterial::ClassId),
TBASEMAT(nummat, dim) {
                this->SetTimeStep(TimeStep);
}

template<class TBASEMAT>
TPZTransientMaterial< TBASEMAT >::TPZTransientMaterial(const TPZTransientMaterial &cp):TPZRegisterClassId(&TPZTransientMaterial::ClassId),
TBASEMAT(cp) {
                this->fTemporalIntegrator = cp.fTemporalIntegrator;
                this->fStep = cp.fStep;
                this->fTimeStep = cp.fTimeStep;
}

template<class TBASEMAT>
TPZTransientMaterial< TBASEMAT >::~TPZTransientMaterial() {
                //NOTHING TO BE DONE
}

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::Contribute(TPZMaterialData &data,
                                                  REAL weight,
                                                  TPZFMatrix<STATE> &ek,
                                                  TPZFMatrix<STATE> &ef) {
                
                // Mostly for implicit
    int numbersol = data.sol.size();
    if (numbersol != 1) {
        DebugStop();
    }

                if (this->fStep == ECurrent){
                                TBASEMAT::Contribute(data,weight,ek,ef);
                                ContributeSolutionRhs(data.sol[0], data.phi, weight, ef);
                                ContributeTangent(data.sol[0], data.phi, weight, ek);
                                return;
                }
                
                if (this->fStep == ELast){
                                this->ContributeSolutionRhs(data.sol[0], data.phi, weight, ef);
                                return;
                }
                
                // Mostly for explicit
                if (this->fStep == EMassMatrix){
                                this->ContributeTangent(data.sol[0], data.phi, weight, ek);
                                return;
                }
                
                if (this->fStep == EFluxOnly){ //Calcula ef = F-ku
                                TBASEMAT::Contribute(data,weight,ek,ef);
                                return;
                }
                
                
                PZError << "ERROR! " << __PRETTY_FUNCTION__ << " at LINE " << __LINE__ << std::endl;
                
}

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::ContributeBC(TPZMaterialData &data,
                                                    REAL weight,
                                                    TPZFMatrix<STATE> &ek,
                                                    TPZFMatrix<STATE> &ef,
                                                    TPZBndCond &bc) {
                // Mostly for implicit
                if (this->fStep == ECurrent){
                                TBASEMAT::ContributeBC(data,weight,ek,ef,bc);
                                return;
                }
                
                if (this->fStep == ELast){
                                return;
                }
                
                
                // Mostly for explicit
                if (this->fStep == EMassMatrix){
                                TPZFNMatrix<1000,STATE> fakeef(ek.Rows(),1,0.);
                                TBASEMAT::ContributeBC(data,weight,ek,fakeef,bc);
                                return;
                }
                if (this->fStep == EFluxOnly){ //Calcula ef = F-ku
                                TPZFNMatrix<1000> fakeef(ef.Rows(),ef.Rows(),0.);
                                TBASEMAT::ContributeBC(data,weight,ek,ef,bc);
                                return;
                }
                
                
                PZError << "ERROR! " << __PRETTY_FUNCTION__ << " at LINE " << __LINE__ << std::endl;
}

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright,
                                                           REAL weight,
                                                           TPZFMatrix<STATE> &ek,
                                                           TPZFMatrix<STATE> &ef) {
                
                // Mostly for implicit
                if (this->fStep == ECurrent){
                                TBASEMAT::ContributeInterface(data,dataleft,dataright, weight, ek, ef);
                                return;
                }
                
                if (this->fStep == ELast){
                                return;
                }
                
                // Mostly for explicit
                if (this->fStep == EMassMatrix){
                                return;
                }
                if (this->fStep == EFluxOnly){ //Calcula ef = F-ku
                                TBASEMAT::ContributeInterface(data,dataleft,dataright, weight, ek, ef);
                                return;
                }
                
                
                PZError << "ERROR! " << __PRETTY_FUNCTION__ << " at LINE " << __LINE__ << std::endl;
                
}

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft,
                                                             REAL weight, 
                                                             TPZFMatrix<STATE> &ek,
                                                             TPZFMatrix<STATE> &ef,
                                                             TPZBndCond &bc) {
                // Mostly for implicit
                if (this->fStep == ECurrent){
                                TBASEMAT::ContributeBCInterface(data,dataleft, weight,ek, ef, bc);
                                return;
                }
                
                if (this->fStep == ELast){
                                return;
                }
                
                
                // Mostly for explicit
                if (this->fStep == EMassMatrix){
                                return;
                }
                if (this->fStep == EFluxOnly){ //Calcula ef = F-ku
                                TBASEMAT::ContributeBCInterface(data, dataleft, weight,  ek, ef, bc);
                                return;
                }
                
                
                PZError << "ERROR! " << __PRETTY_FUNCTION__ << " at LINE " << __LINE__ << std::endl;
                
}

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::ContributeSolutionRhs(TPZVec<STATE> &sol, TPZFMatrix<REAL> &phi, REAL weight, TPZFMatrix<STATE> &ef) {
                REAL Mult = +1.; 
                //Last solution is added to residual
                if (this->fStep == ECurrent) Mult = -1.; 
                //Current solution is subtracted from residual
                const int phr = phi.Rows();
                const int nstate = this->NStateVariables();
                const REAL DeltaT = this->TimeStep();
                int i, k;
                for(i = 0; i < phr; i++) {
                                for(k = 0; k < nstate; k++){
                                                ef(i*nstate+k, 0) += (STATE)(Mult * weight) * sol[k] * (STATE)(phi(i,0) / DeltaT);
                                }//k
                }//i
}//method

template<class TBASEMAT>
void TPZTransientMaterial< TBASEMAT >::ContributeTangent(TPZVec<STATE> &sol, TPZFMatrix<REAL> &phi, REAL weight, TPZFMatrix<STATE> &ek) {
                const int phr = phi.Rows();
                const int nstate = this->NStateVariables();
                const REAL DeltaT = this->TimeStep();
                int i, j, k;
                for(i = 0; i < phr; i++) {
                                for(j = 0; j < phr; j++){
                                                for(k = 0; k < nstate; k++){
                                                                ek(i*nstate+k, j*nstate+k) += weight * phi(i,0) * phi(j,0) / DeltaT;
                                                }//k
                                }//j
                }//i
}//method

#ifndef STATE_COMPLEX
#include "pzpoisson3d.h"
template class TPZTransientMaterial< TPZMatPoisson3d >;

#include "pznonlinearpoisson3d.h"
template class TPZTransientMaterial< TPZNonLinearPoisson3d >;

#include "pzburger.h"
template class TPZTransientMaterial< TPZBurger >;

void TestInstantiations() {
                TPZTransientMaterial< TPZMatPoisson3d > A(1,1,1.);
                TPZTransientMaterial< TPZNonLinearPoisson3d > B(1,1,1.);
                TPZTransientMaterial< TPZBurger > C(1,1,1.);
}

#endif