arquivos-html/html/swelling_8h_source.html

 #ifndef SWELLINGHPP
 #define SWELLINGHPP

 #include "TPZMaterial.h"
 #include "pzfmatrix.h"

 #ifdef _AUTODIFF
 #include "fadType.h"
 #endif

 class TPZSwelling : public TPZMaterial {

                 int fComputationMode;
                 TPZFMatrix<STATE> fKperm;
                 STATE fLambda;
                 STATE fGamma;
                 STATE fShear;
                 STATE fAlfa;
                 STATE fM;
                 STATE fDPlus;
                 STATE fDMinus;
                 STATE frHinder;
                 STATE fInitDeform;
                 STATE fCfc;
                 STATE fNf0;
                 STATE fNPlus0;
                 STATE fNMinus0;

                 STATE fTheta;
                 STATE fDelt;
                 static STATE gExtConc;

 #ifdef _AUTODIFF

                 static REAL gFaraday;
                 static REAL gVPlus;
                 static REAL gVMinus;
                 static REAL gRGas;
                 static REAL gTemp;
                 static REAL gMuRef[3];

 #else

                 static STATE gFaraday;
                 static STATE gVPlus;
                 static STATE gVMinus;
                 static STATE gRGas;
                 static STATE gTemp;
                 static STATE gMuRef[3];

 #endif

                 public :


                 TPZSwelling(int matindex, STATE lambda, STATE shear, STATE alfa, STATE M, STATE Gamma, STATE Kperm, STATE DPlus, STATE DMinus,
                                                                 STATE rHinder, STATE Cfc, STATE Nf0, STATE NPlus0, STATE NMinus0);

                 virtual ~TPZSwelling();

                 virtual int Dimension() const  override { return 3;}

                 virtual int NStateVariables() const override{ return 8;}

                 virtual void Print(std::ostream & out) override;

                 virtual std::string Name()  override { return "TPZSwelling"; }

                 void SetComputationMode(int mode) {
                                 switch(mode) {
                                                 case 0:
                                                                 fComputationMode = mode;
                                                                 break;
                                                 case 1:
                                                                 fComputationMode = mode;
                                                                 break;
                                                 default:
                                                                 std::cout << "ComputationMode illegal mode = " << mode << std::endl;
                                 }
                 }

                 virtual void Contribute(TPZMaterialData &data,
                                                                                                                 REAL weight,
                                                                                                                 TPZFMatrix<STATE> &ek,
                                                                                                                 TPZFMatrix<STATE> &ef) override {
                                 std::cout << "TPZSwelling::Contribute not implemented\n";
                 }
                 virtual void Contribute(TPZMaterialData &data,
                                                                                                                 REAL weight,
                                                                                                                 TPZFMatrix<STATE> &ef) override {
                                 std::cout << "TPZSwelling::Contribute not implemented\n";
                 }

                 virtual void ContributeBC(TPZMaterialData &data,
                                                                                                                   REAL weight,
                                                                                                                   TPZFMatrix<STATE> &ek,
                                                                                                                   TPZFMatrix<STATE> &ef,
                                                                                                                   TPZBndCond &bc) override;
                 virtual void ContributeBC(TPZMaterialData &data,
                                                                                                                   REAL weight,
                                                                                                                   TPZFMatrix<STATE> &ef,
                                                                                                                   TPZBndCond &bc) override
                 {
                                 TPZMaterial::ContributeBC(data,weight,ef,bc);
                 }


 #ifdef _AUTODIFF

                 virtual void ContributeElastEnergy(
                                                                                                                                                    TPZVec<FADFADREAL> &dsol,
                                                                                                                                                    FADFADREAL &U,
                                                                                                                                                    REAL weight);

                 virtual void ContributeResidual(TPZVec<REAL> & x,
                                                                                                                                                 TPZVec<FADREAL> & sol,
                                                                                                                                                 TPZVec<FADREAL> &dsol,
                                                                                                                                                 TPZFMatrix<REAL> &phi,
                                                                                                                                                 TPZFMatrix<REAL> &dphi,
                                                                                                                                                 TPZVec<FADREAL> &RES,
                                                                                                                                                 REAL weight);

                 virtual void ContributePrevResidual(TPZVec<REAL> & x,
                                                                                                                                                                 TPZVec<FADREAL> & sol,
                                                                                                                                                                 TPZVec<FADREAL> &dsol,
                                                                                                                                                                 TPZFMatrix<REAL> &phi,
                                                                                                                                                                 TPZFMatrix<REAL> &dphi,
                                                                                                                                                                 TPZVec<FADREAL> &RES,
                                                                                                                                                                 REAL weight);

                 virtual void ContributeBCEnergy(TPZVec<REAL> & x,
                                                                                                                                                 TPZVec<FADFADREAL> & sol, FADFADREAL &U,
                                                                                                                                                 REAL weight, TPZBndCond &bc) {
                                 std::cout << "TPZSwelling::ContributeBCEnergy is not implemented\n";
                 }

 #endif

 private:

                 void ExactSolution(TPZVec<STATE> &mu, STATE ksi, STATE pres, TPZVec<STATE> &N);

                 void ComputeN(TPZVec<STATE> &N, TPZVec<STATE> &mu, STATE ksi);

                 void ComputeInitialGuess(TPZVec<STATE> &mu, STATE J, STATE &pres, STATE &ksi, TPZVec<STATE> &N);

 #ifdef _AUTODIFF

                 void ComputeW(FADFADREAL &W, TPZVec<STATE> &N);

 #endif

                 void ComputeN(TPZVec<STATE> &mu, STATE ksi, STATE pressure, TPZVec<STATE> &N);

 #ifdef _AUTODIFF

                 void ComputeN(TPZVec<FADREAL> &sol, TPZVec<FADREAL> &N);

                 void ComputeN(TPZVec<FADREAL> &sol, TPZVec<REAL> &N);

 #endif

                 void NResidual(TPZVec<STATE> &mu, STATE ksi, STATE pressure, TPZVec<STATE> &N, TPZFMatrix<STATE> &res, TPZFMatrix<STATE> &tangent);

 #ifdef _AUTODIFF

                 void NResidual(TPZVec<FADREAL> &sol, TPZVec<FADREAL> &N);

                 static void Solve(TPZVec<TPZVec<FADREAL> > &tangent, TPZVec<FADREAL> &res);
 public:

                 static int main();

 #endif

                 int NumCases();
                 void LoadState(TPZFMatrix<STATE> &state);
                 void ComputeTangent(TPZFMatrix<STATE> &tangent,TPZVec<REAL> &coefs, int cases);
                 void Residual(TPZFMatrix<STATE> &res, int cases);
                 static TPZFMatrix<STATE> gState;
                 static TPZFMatrix<REAL> gphi,gdphi;

 public:

                 virtual int VariableIndex(const std::string &name) override;
                 virtual int NSolutionVariables(int var) override;

 protected:
                 virtual void Solution(TPZVec<STATE> &Sol,TPZFMatrix<STATE> &DSol,TPZFMatrix<REAL> &axes,int var,TPZVec<STATE> &Solout) override;
 public:
                 virtual void Solution(TPZMaterialData &data,int var,TPZVec<STATE> &Solout) override
                 {
         int numbersol = data.sol.size();
         if (numbersol != 1) {
             DebugStop();
         }
                                 Solution(data.sol[0],data.dsol[0],data.axes,var,Solout);
                 }
     public:
 virtual int ClassId() const override;

 };

 #endif
TPZSwelling::fDPlus
STATE fDPlus
Diffusion coeficient for cations [mm^2/s].
Definition: swelling.h:42

TPZSwelling::~TPZSwelling
virtual ~TPZSwelling()
Definition: swelling.cpp:72

TPZSwelling::fKperm
TPZFMatrix< STATE > fKperm
Hydraulic permeability .
Definition: swelling.h:30

TPZSwelling::ContributeBC
virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix< STATE > &ef, TPZBndCond &bc) override
It computes a contribution to the stiffness matrix and load vector at one BC integration point...
Definition: swelling.h:168

TPZSwelling::fNMinus0
STATE fNMinus0
Initial anion volume fraction (no dimension)
Definition: swelling.h:56

TPZSwelling::Solution
virtual void Solution(TPZVec< STATE > &Sol, TPZFMatrix< STATE > &DSol, TPZFMatrix< REAL > &axes, int var, TPZVec< STATE > &Solout) override
Computes a post-processed solution variable corresponding to the variable index.
Definition: swelling.cpp:120

TPZSwelling::fM
STATE fM
Storage modulus [N/mm^2].
Definition: swelling.h:40

TPZSwelling::fDMinus
STATE fDMinus
Diffusion coeficient for anions [mm^2/s].
Definition: swelling.h:44

bc
clarg::argBool bc("-bc", "binary checkpoints", false)

TPZSwelling::NumCases
int NumCases()
Methods needed to perform convergence checks.

TPZMaterial.h

TPZSwelling::Print
virtual void Print(std::ostream &out) override
Prints out the data associated with the material.
Definition: swelling.cpp:76

TPZSwelling::gExtConc
static STATE gExtConc
External concentration (used as reference value for pressure) [mmol/mm^3].
Definition: swelling.h:63

TPZSwelling::fShear
STATE fShear
Shear modulus [N/mm^2].
Definition: swelling.h:36

TPZMaterialData::dsol
TPZGradSolVec dsol
vector of the derivatives of the solution at the integration point
Definition: pzmaterialdata.h:79

TPZSwelling
The TPZSwelling class implements a numerical model of swelling material coupling flow through porous ...
Definition: swelling.h:21

TPZSwelling::fDelt
STATE fDelt
Timestep [s].
Definition: swelling.h:61

TPZSwelling::NStateVariables
virtual int NStateVariables() const override
Number of state variables, in this case:  3 displacements, 1 pressure, 3 eletrochemical potencials...
Definition: swelling.h:127

TPZVec
This class implements a simple vector storage scheme for a templated class T. Utility.
Definition: pzgeopoint.h:19

TPZSwelling::gdphi
static TPZFMatrix< REAL > gdphi
Definition: swelling.h:281

TPZSwelling::Solution
virtual void Solution(TPZMaterialData &data, int var, TPZVec< STATE > &Solout) override
Returns the solution associated with the var index based on the finite element approximation.
Definition: swelling.h:294

TPZSwelling::ExactSolution
void ExactSolution(TPZVec< STATE > &mu, STATE ksi, STATE pres, TPZVec< STATE > &N)
Definition: swelling.cpp:779

TPZSwelling::ComputeTangent
void ComputeTangent(TPZFMatrix< STATE > &tangent, TPZVec< REAL > &coefs, int cases)
Computes the tangent matrix for a given loadcase.

TPZSwelling::fAlfa
STATE fAlfa
Biot coupling coeficient (no dimension)
Definition: swelling.h:38

TPZMaterial
This abstract class defines the behaviour which each derived class needs to implement.
Definition: TPZMaterial.h:39

TPZSwelling::gTemp
static STATE gTemp
Absolute temperature [K].
Definition: swelling.h:89

TPZSwelling::gRGas
static STATE gRGas
gas constant [Nmm/(mmol K)]
Definition: swelling.h:87

TPZSwelling::fCfc
STATE fCfc
Fixed charge density [mmoleq/mm^3].
Definition: swelling.h:50

TPZVec::size
int64_t size() const
Returns the number of elements of the vector.
Definition: pzvec.h:196

TPZSwelling::fInitDeform
STATE fInitDeform
Initial deformation (assuming everything occurs isotropically, a constant is suficient (no dimension)...
Definition: swelling.h:48

TPZSwelling::fNf0
STATE fNf0
Initial fluid volume fraction (do dimension)
Definition: swelling.h:52

pzfmatrix.h
Contains TPZMatrixclass which implements full matrix (using column major representation).

DebugStop
#define DebugStop()
Returns a message to user put a breakpoint in.
Definition: pzerror.h:20

TPZBndCond
This class defines the boundary condition for TPZMaterial objects.
Definition: pzbndcond.h:29

TPZSwelling::Name
virtual std::string Name() override
Returns the name of the material.
Definition: swelling.h:131

TPZSwelling::fTheta
STATE fTheta
Timestepping parameter theta (no dimension)
Definition: swelling.h:59

TPZSwelling::gFaraday
static STATE gFaraday
Faraday constant [C/mmol].
Definition: swelling.h:81

TPZMaterialData::axes
TPZFNMatrix< 9, REAL > axes
axes indicating the directions of the derivatives of the shapefunctions
Definition: pzmaterialdata.h:63

TPZSwelling::ComputeN
void ComputeN(TPZVec< STATE > &N, TPZVec< STATE > &mu, STATE ksi)
Computes the value of the N coeficients in function of ksi and mus, iterative method, inverting the Hessian of W.

test.res
string res
Definition: test.py:151

TPZSwelling::fComputationMode
int fComputationMode
Computation mode:  0->residual wrt to time   1->residual and tangent wrt to time .
Definition: swelling.h:28

TPZSwelling::gphi
static TPZFMatrix< REAL > gphi
Variables which holds the state variables used in the check convergence procedure.
Definition: swelling.h:281

TPZSwelling::fGamma
STATE fGamma
Osmotic coeficient (no dimension)
Definition: swelling.h:34

TPZMaterial::ContributeBC
virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix< STATE > &ek, TPZFMatrix< STATE > &ef, TPZBndCond &bc)=0
It computes a contribution to the stiffness matrix and load vector at one BC integration point...

TPZFMatrix< STATE >

TPZSwelling::TPZSwelling
TPZSwelling(int matindex, STATE lambda, STATE shear, STATE alfa, STATE M, STATE Gamma, STATE Kperm, STATE DPlus, STATE DMinus, STATE rHinder, STATE Cfc, STATE Nf0, STATE NPlus0, STATE NMinus0)
Constructor of the class, where the user needs to specify the most important parameters.
Definition: swelling.cpp:45

TPZSwelling::LoadState
void LoadState(TPZFMatrix< STATE > &state)
Loads the state within the current object, to be used when computing the tangent matrix.

TPZSwelling::Contribute
virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix< STATE > &ek, TPZFMatrix< STATE > &ef) override
It computes a contribution to the stiffness matrix and load vector at one integration point...
Definition: swelling.h:151

TPZSwelling::fNPlus0
STATE fNPlus0
Initial cation volume fraction (no dimension)
Definition: swelling.h:54

TPZSwelling::ComputeInitialGuess
void ComputeInitialGuess(TPZVec< STATE > &mu, STATE J, STATE &pres, STATE &ksi, TPZVec< STATE > &N)
Computes the aproximate values of the pressure, ksi and N based on mu and J by direct inversion of th...
Definition: swelling.cpp:750

TPZMaterialData
Definition: pzmaterialdata.h:33

TPZSwelling::VariableIndex
virtual int VariableIndex(const std::string &name) override
Definition: swelling.cpp:111

TPZSwelling::gMuRef
static STATE gMuRef[3]
Reference chemical potentials (order f,plus,minus) [mV].
Definition: swelling.h:91

TPZSwelling::Contribute
virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix< STATE > &ef) override
It computes a contribution to the residual vector at one integration point.
Definition: swelling.h:157

TPZSwelling::SetComputationMode
void SetComputationMode(int mode)
Definition: swelling.h:133

TPZSwelling::gVPlus
static STATE gVPlus
Molar volume cation [mm^3/mmol].
Definition: swelling.h:83

fadType.h

TPZSwelling::ClassId
virtual int ClassId() const override
Define the class id associated with the class.
Definition: swelling.cpp:842

TPZSwelling::frHinder
STATE frHinder
Hindrance factor (no dimension)
Definition: swelling.h:46

TPZSwelling::fLambda
STATE fLambda
Compression modulus [N/mm^2].
Definition: swelling.h:32

TPZSwelling::Dimension
virtual int Dimension() const override
Dimension of the problem.
Definition: swelling.h:121

TPZSwelling::gState
static TPZFMatrix< STATE > gState
Variables which holds the state variables used in the check convergence procedure.
Definition: swelling.h:279

main
int main()
Definition: benchadolc.cc:42

TPZSwelling::ContributeBC
virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix< STATE > &ek, TPZFMatrix< STATE > &ef, TPZBndCond &bc) override
It computes a contribution to the stiffness matrix and load vector at one BC integration point...
Definition: swelling.cpp:128

TPZMaterialData::sol
TPZSolVec sol
vector of the solutions at the integration point
Definition: pzmaterialdata.h:77

TPZSwelling::gVMinus
static STATE gVMinus
Molar volume anions [mm^3/mmol].
Definition: swelling.h:85

TPZSwelling::NSolutionVariables
virtual int NSolutionVariables(int var) override
Returns the number of solution variables associated with a variable index.
Definition: swelling.cpp:115

TPZSwelling::Residual
void Residual(TPZFMatrix< STATE > &res, int cases)
Computes the residual for the given state variable.

TPZSwelling::NResidual
void NResidual(TPZVec< STATE > &mu, STATE ksi, STATE pressure, TPZVec< STATE > &N, TPZFMatrix< STATE > &res, TPZFMatrix< STATE > &tangent)
Computes the residual and tangent vector of the system of equations which determines N...