void L2ProjectionResidual<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell)
{
for (std::size_t node=0; node < numNodes; ++node)
{
/*TResidual(cell,node)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp)
{
TResidual(cell,node) += ( projectedField(cell,qp)-
Pfield(cell, qp))*wBF(cell,node,qp);
}*/
for (std::size_t k=0; k<numDims*numDims; ++k){
TResidual(cell,node,k)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp){
// need to transform tensor valued Pfield to a vector for projectedField and TResidual
TResidual(cell,node,k) += (projectedField(cell,qp,k) -
Pfield(cell,qp,k/numDims,k%numDims))*wBF(cell,node,qp);
//cout << "Projected Field: " << Sacado::ScalarValue<ScalarT>::eval(projectedField(cell,node,k)) << std::endl;
//cout << "PField: " << Sacado::ScalarValue<ScalarT>::eval(Pfield(cell,node,k/numDims,k%numDims)) << std::endl;
}
}
}
}
}
void ScalarL2ProjectionResidual<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
ScalarT J(1);
for (int cell=0; cell < workset.numCells; ++cell)
{
for (int qp=0; qp < numQPs; ++qp)
{
Intrepid::Tensor<ScalarT> F(numDims, DefGrad,cell, qp,0,0);
J = Intrepid::det(F);
tauH(cell,qp) = 0.0;
for (int i=0; i<numDims; i++){
tauH(cell,qp) += J*Pstress(cell, qp, i,i)/numDims;
}
}
}
for (int cell=0; cell < workset.numCells; ++cell)
{
for (int node=0; node < numNodes; ++node)
{
TResidual(cell,node)=0.0;
}
}
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
for (int qp=0; qp < numQPs; ++qp) {
TResidual(cell,node) += ( projectedStress(cell,qp)-
tauH(cell, qp))*wBF(cell,node,qp);
}
}
}
}
void NSThermalEqResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools FST;
FST::scalarMultiplyDataData<ScalarT> (flux, ThermalCond, TGrad);
FST::integrate<ScalarT>(TResidual, flux, wGradBF, Intrepid2::COMP_CPP, false); // "false" overwrites
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
convection(cell,qp) = 0.0;
if (haveSource) convection(cell,qp) -= Source(cell,qp);
if (workset.transientTerms && enableTransient)
convection(cell,qp) += rho(cell,qp) * Cp(cell,qp) * Tdot(cell,qp);
if (haveFlow) {
for (std::size_t i=0; i < numDims; ++i) {
convection(cell,qp) +=
rho(cell,qp) * Cp(cell,qp) * V(cell,qp,i) * TGrad(cell,qp,i);
}
}
}
}
FST::integrate<ScalarT>(TResidual, convection, wBF, Intrepid2::COMP_CPP, true); // "true" sums into
if (haveSUPG) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t j=0; j < numDims; ++j) {
TResidual(cell,node) +=
rho(cell,qp) * Cp(cell,qp) * TauT(cell,qp) * convection(cell,qp) *
V(cell,qp,j) * wGradBF(cell,node,qp,j);
}
}
}
}
}
}
void UnSatPoroElasticityResidMass<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
Albany::MDArray strainold = (*workset.stateArrayPtr)[strainName];
Albany::MDArray porosityold = (*workset.stateArrayPtr)[porosityName];
Albany::MDArray porePressureold = (*workset.stateArrayPtr)[porePressureName];
Albany::MDArray vgSatold = (*workset.stateArrayPtr)[satName];
// Set Warning message
if (porosityold(1,1) < 0 || porosity(1,1) < 0 ) {
std::cout << "negative porosity detected. Error! \n";
}
switch (numDims) {
case 3:
// Pore-fluid diffusion coupling.
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
TResidual(cell,node)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
// Transient partial saturated flow
ScalarT trstrain = 0.0;
for (std::size_t i(0); i < numDims; ++i){
trstrain += strainold(cell,qp,i,i);
}
// Volumetric Constraint Term
TResidual(cell,node) += -vgSat(cell, qp)*(
strain(cell,qp,0,0) + strain(cell,qp,1,1)+strain(cell,qp,2,2) - trstrain
)
*wBF(cell, node, qp) ;
// Pore-fluid Resistance Term
TResidual(cell,node) += -porosity(cell,qp)*(
vgSat(cell, qp) -vgSatold(cell, qp)
)*wBF(cell, node, qp);
}
}
}
break;
case 2:
// Pore-fluid diffusion coupling.
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
TResidual(cell,node)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
// Transient partial saturated flow
ScalarT trstrain = 0.0;
for (std::size_t i(0); i < numDims; ++i){
trstrain += strainold(cell,qp,i,i);
}
// Volumetric Constraint Term
TResidual(cell,node) += -vgSat(cell, qp)*(
strain(cell,qp,0,0) + strain(cell,qp,1,1) - trstrain
)*wBF(cell, node, qp) ;
// Pore-fluid Resistance Term
TResidual(cell,node) += -porosity(cell,qp)*(vgSat(cell, qp)
-vgSatold(cell, qp)
)*wBF(cell, node, qp);
}
}
}
break;
case 1:
// Pore-fluid diffusion coupling.
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
TResidual(cell,node)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
// Transient partial saturated flow
ScalarT trstrain = 0.0;
for (std::size_t i(0); i < numDims; ++i){
trstrain += strainold(cell,qp,i,i);
}
// Volumetric Constraint Term
TResidual(cell,node) += -vgSat(cell, qp)*(
strain(cell,qp,0,0) - trstrain
)*wBF(cell, node, qp) ;
// Pore-fluid Resistance Term
TResidual(cell,node) += -(vgSat(cell, qp)
-vgSatold(cell, qp)
)*porosity(cell, qp)*
wBF(cell, node, qp);
}
}
}
break;
}
// Pore-Fluid Diffusion Term
ScalarT dt = deltaTime(0);
FST::scalarMultiplyDataData<ScalarT> (flux, vgPermeability, TGrad); // flux_i = k I_ij p_j
for (std::size_t cell=0; cell < workset.numCells; ++cell){
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t dim=0; dim <numDims; ++dim){
fluxdt(cell, qp, dim) = -flux(cell,qp,dim)*dt; // should replace the number with dt
}
}
}
FST::integrate<ScalarT>(TResidual, fluxdt, wGradBF, Intrepid::COMP_CPP, true); // "true" sums into
//---------------------------------------------------------------------------//
// Stabilization Term (only 2D and 3D problem need stabilizer)
// Penalty Term
for (std::size_t cell=0; cell < workset.numCells; ++cell){
porePbar = 0.0;
vol = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
porePbar += weights(cell,qp)*(vgSat(cell,qp)
-vgSatold(cell, qp)
);
vol += weights(cell,qp);
}
porePbar /= vol;
for (std::size_t qp=0; qp < numQPs; ++qp) {
pterm(cell,qp) = porePbar;
}
for (std::size_t node=0; node < numNodes; ++node) {
trialPbar = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
trialPbar += wBF(cell,node,qp);
}
trialPbar /= vol;
// for (std::size_t qp=0; qp < numQPs; ++qp) {
// tpterm(cell,node,qp) = trialPbar;
// }
}
}
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
TResidual(cell,node) -= (vgSat(cell, qp)
-vgSatold(cell, qp)
)
*stabParameter(cell, qp)*porosity(cell, qp)*
( wBF(cell, node, qp)
// -tpterm(cell,node,q )
);
TResidual(cell,node) += pterm(cell,qp)*stabParameter(cell, qp)*porosity(cell, qp)*
( wBF(cell, node, qp)
// -tpterm(cell,node,qps )
);
}
}
}
}
void TLPoroPlasticityResidMass<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
bool print = false;
//if (typeid(ScalarT) == typeid(RealType)) print = true;
typedef Intrepid::FunctionSpaceTools FST;
typedef Intrepid::RealSpaceTools<ScalarT> RST;
// Use previous time step for Backward Euler Integration
Albany::MDArray porePressureold
= (*workset.stateArrayPtr)[porePressureName];
Albany::MDArray Jold;
if (haveMechanics) {
Jold = (*workset.stateArrayPtr)[JName];
}
// Pore-fluid diffusion coupling.
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
TResidual(cell,node)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
// Volumetric Constraint Term
if (haveMechanics) {
TResidual(cell,node) -= biotCoefficient(cell, qp)
* (std::log(J(cell,qp)/Jold(cell,qp)))
* wBF(cell, node, qp) ;
}
// Pore-fluid Resistance Term
TResidual(cell,node) -= ( porePressure(cell,qp)-porePressureold(cell, qp) )
/ biotModulus(cell, qp)*wBF(cell, node, qp);
}
}
}
// Pore-Fluid Diffusion Term
ScalarT dt = deltaTime(0);
if (haveMechanics) {
RST::inverse(F_inv, defgrad);
RST::transpose(F_invT, F_inv);
FST::scalarMultiplyDataData<ScalarT>(JF_invT, J, F_invT);
FST::scalarMultiplyDataData<ScalarT>(KJF_invT, kcPermeability, JF_invT);
FST::tensorMultiplyDataData<ScalarT>(Kref, F_inv, KJF_invT);
FST::tensorMultiplyDataData<ScalarT> (flux, Kref, TGrad); // flux_i = k I_ij p_j
} else {
FST::scalarMultiplyDataData<ScalarT> (flux, kcPermeability, TGrad); // flux_i = kc p_i
}
for (std::size_t cell=0; cell < workset.numCells; ++cell){
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t dim=0; dim <numDims; ++dim){
fluxdt(cell, qp, dim) = -flux(cell,qp,dim)*dt;
}
}
}
FST::integrate<ScalarT>(TResidual, fluxdt,
wGradBF, Intrepid::COMP_CPP, true); // "true" sums into
//---------------------------------------------------------------------------//
// Stabilization Term
for (std::size_t cell=0; cell < workset.numCells; ++cell){
porePbar = 0.0;
vol = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
porePbar += weights(cell,qp)
* (porePressure(cell,qp)-porePressureold(cell, qp) );
vol += weights(cell,qp);
}
porePbar /= vol;
for (std::size_t qp=0; qp < numQPs; ++qp) {
pterm(cell,qp) = porePbar;
}
for (std::size_t node=0; node < numNodes; ++node) {
trialPbar = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
trialPbar += wBF(cell,node,qp);
}
trialPbar /= vol;
for (std::size_t qp=0; qp < numQPs; ++qp) {
tpterm(cell,node,qp) = trialPbar;
}
}
}
ScalarT temp(0);
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
temp = 3.0 - 12.0*kcPermeability(cell,qp)*dt
/(elementLength(cell,qp)*elementLength(cell,qp));
//if ((temp > 0) & stabParameter(cell,qp) > 0) {
if ((temp > 0) & stab_param_ > 0) {
TResidual(cell,node) -=
( porePressure(cell,qp)-porePressureold(cell, qp) )
//* stabParameter(cell, qp)
* stab_param_
* std::abs(temp) // should be 1 but use 0.5 for safety
* (0.5 + 0.5*std::tanh( (temp-1)/kcPermeability(cell,qp) ))
/ biotModulus(cell, qp)
* ( wBF(cell, node, qp)
// -tpterm(cell,node,qp)
);
TResidual(cell,node) += pterm(cell,qp)
//* stabParameter(cell, qp)
* stab_param_
* std::abs(temp) // should be 1 but use 0.5 for safety
* (0.5 + 0.5*std::tanh( (temp-1)/kcPermeability(cell,qp) ))
/ biotModulus(cell, qp)
* ( wBF(cell, node, qp) );
}
}
}
}
}
