void XZHydrostaticResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
std::vector<ScalarT> vel(numLevels);
for (int level=0; level < numLevels; ++level) {
vel[level] = (level+1)*Re;
}
for (int i=0; i < Residual.size(); ++i) Residual(i)=0.0;
for (int cell=0; cell < workset.numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
// Transient Term
Residual(cell,node,level) += rhoDot(cell,qp,level)*wBF(cell,node,qp);
// Advection Term
for (int j=0; j < numDims; ++j) {
Residual(cell,node,level) += vel[level]*rhoGrad(cell,qp,level,j)*wBF(cell,node,qp);
}
}
}
}
}
}
KOKKOS_INLINE_FUNCTION
void StokesFOImplicitThicknessUpdateResid<EvalT, Traits>::
operator() (const StokesFOImplicitThicknessUpdateResid_Tag& tag, const int& cell) const {
double rho_g=rho*g;
for (int node=0; node < numNodes; ++node){
res(node,0)=0.0;
res(node,1)=0.0;
}
for (int qp=0; qp < numQPs; ++qp) {
ScalarT dHdiffdx = 0;//Ugrad(cell,qp,2,0);
ScalarT dHdiffdy = 0;//Ugrad(cell,qp,2,1);
for (int node=0; node < numNodes; ++node) {
dHdiffdx += dH(cell,node) * gradBF(cell,node, qp,0);
dHdiffdy += dH(cell,node) * gradBF(cell,node, qp,1);
}
for (int node=0; node < numNodes; ++node) {
res(node,0) += rho_g*dHdiffdx*wBF(cell,node,qp);
res(node,1) += rho_g*dHdiffdy*wBF(cell,node,qp);
}
}
for (int node=0; node < numNodes; ++node) {
Residual(cell,node,0) = InputResidual(cell,node,0)+res(node,0);
Residual(cell,node,1) = InputResidual(cell,node,1)+res(node,1);
if(numVecDims==3)
Residual(cell,node,2) = InputResidual(cell,node,2);
}
}
void GPAMResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools FST;
//Set Redidual to 0, add Diffusion Term
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t i=0; i<vecDim; i++) Residual(cell,node,i)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t i=0; i<vecDim; i++) {
for (std::size_t dim=0; dim<numDims; dim++) {
Residual(cell,node,i) += Cgrad(cell, qp, i, dim) * wGradBF(cell, node, qp, dim);
} } } } }
// These both should always be true if transient is enabled
if (workset.transientTerms && enableTransient) {
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 i=0; i<vecDim; i++) {
Residual(cell,node,i) += CDot(cell, qp, i) * wBF(cell, node, qp);
} } } } }
if (convectionTerm) {
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 i=0; i<vecDim; i++) {
for (std::size_t dim=0; dim<numDims; dim++) {
Residual(cell,node,i) += u[dim]*Cgrad(cell, qp, i, dim) * wBF(cell, node, qp);
} } } } } }
}
void XScalarAdvectionResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
std::vector<ScalarT> vel(numLevels);
for (int level=0; level < numLevels; ++level) {
vel[level] = (level+1)*Re;
}
for (int i=0; i < workset.numCells; ++i)
for (int node=0; node < numNodes; ++node)
Residual(i, node)=0.0;
for (int cell=0; cell < workset.numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
for (int node=0; node < numNodes; ++node) {
if (2==numRank) {
Residual(cell,node) += XDot(cell,qp)*wBF(cell,node,qp);
for (int j=0; j < numDims; ++j)
Residual(cell,node) += vel[0] * XGrad(cell,qp,j)*wBF(cell,node,qp);
} else {
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "no impl");
//Irina TOFIX
/* for (int level=0; level < numLevels; ++level) {
Residual(cell,node,level) += XDot(cell,qp,level)*wBF(cell,node,qp);
for (int j=0; j < numDims; ++j)
Residual(cell,node,level) += vel[level] * XGrad(cell,qp,level,j)*wBF(cell,node,qp);
}
*/ }
}
}
}
}
void MicroResidual<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools FST;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t idim=0; idim<numDims; idim++)
for (std::size_t jdim=0; jdim<numDims; jdim++)
ExResidual(cell,node,idim,jdim)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t i=0; i<numDims; i++) {
for (std::size_t j=0; j<numDims; j++) {
for (std::size_t dim=0; dim<numDims; dim++) {
ExResidual(cell,node,i,j) += doubleStress(cell, qp, i, j, dim) * wGradBF(cell, node, qp, dim)
+ microStress(cell, qp, i, j) * wBF(cell, node, qp);
} } } } } }
if (workset.transientTerms && enableTransient)
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 i=0; i<numDims; i++) {
for (std::size_t j=0; j<numDims; j++) {
ExResidual(cell,node,i,j) += epsDotDot(cell, qp, i, j) * wBF(cell, node, qp);
} } } } }
}
void StokesFOImplicitThicknessUpdateResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
// Initialize residual to 0.0
Kokkos::deep_copy(Residual.get_kokkos_view(), ScalarT(0.0));
Intrepid::FieldContainer<ScalarT> res(numNodes,3);
double rho_g=rho*g;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (int i = 0; i < res.size(); i++) res(i) = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
ScalarT dHdiffdx = 0;//Ugrad(cell,qp,2,0);
ScalarT dHdiffdy = 0;//Ugrad(cell,qp,2,1);
for (std::size_t node=0; node < numNodes; ++node) {
dHdiffdx += (H(cell,node)-H0(cell,node)) * gradBF(cell,node, qp,0);
dHdiffdy += (H(cell,node)-H0(cell,node)) * gradBF(cell,node, qp,1);
}
for (std::size_t node=0; node < numNodes; ++node) {
res(node,0) += rho_g*dHdiffdx*wBF(cell,node,qp);
res(node,1) += rho_g*dHdiffdy*wBF(cell,node,qp);
}
}
for (std::size_t node=0; node < numNodes; ++node) {
Residual(cell,node,0) = res(node,0);
Residual(cell,node,1) = res(node,1);
}
}
}
void ElasticityResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t dim=0; dim<numDims; dim++) ExResidual(cell,node,dim)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t i=0; i<numDims; i++) {
for (std::size_t dim=0; dim<numDims; dim++) {
ExResidual(cell,node,i) += Stress(cell, qp, i, dim) * wGradBF(cell, node, qp, dim);
} } } } }
if (workset.transientTerms && enableTransient)
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 i=0; i<numDims; i++) {
ExResidual(cell,node,i) += uDotDot(cell, qp, i) * wBF(cell, node, qp);
} } } }
// FST::integrate<ScalarT>(ExResidual, Stress, wGradBF, Intrepid::COMP_CPP, false); // "false" overwrites
}
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 StokesL1L2Resid<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) {
for (std::size_t i=0; i<vecDim; i++) Residual(cell,node,i)=0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
Residual(cell,node,0) += 2.0*muLandIce(cell,qp)*((2.0*epsilonXX(cell,qp) + epsilonYY(cell,qp))*wGradBF(cell,node,qp,0) +
epsilonXY(cell,qp)*wGradBF(cell,node,qp,1)) +
force(cell,qp,0)*wBF(cell,node,qp);
Residual(cell,node,1) += 2.0*muLandIce(cell,qp)*(epsilonXY(cell,qp)*wGradBF(cell,node,qp,0) +
(epsilonXX(cell,qp) + 2.0*epsilonYY(cell,qp))*wGradBF(cell,node,qp,1))
+ force(cell,qp,1)*wBF(cell,node,qp);
}
}
}
}
void StokesFOImplicitThicknessUpdateResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
#ifndef ALBANY_KOKKOS_UNDER_DEVELOPMENT
typedef Intrepid2::FunctionSpaceTools FST;
// Initialize residual to 0.0
Intrepid2::FieldContainer_Kokkos<ScalarT, PHX::Layout, PHX::Device> res(numNodes,2);
double rho_g=rho*g;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
res.initialize();
for (std::size_t qp=0; qp < numQPs; ++qp) {
ScalarT dHdiffdx = 0;//Ugrad(cell,qp,2,0);
ScalarT dHdiffdy = 0;//Ugrad(cell,qp,2,1);
for (std::size_t node=0; node < numNodes; ++node) {
dHdiffdx += dH(cell,node) * gradBF(cell,node, qp,0);
dHdiffdy += dH(cell,node) * gradBF(cell,node, qp,1);
}
for (std::size_t node=0; node < numNodes; ++node) {
res(node,0) += rho_g*dHdiffdx*wBF(cell,node,qp);
res(node,1) += rho_g*dHdiffdy*wBF(cell,node,qp);
}
}
for (std::size_t node=0; node < numNodes; ++node) {
Residual(cell,node,0) = InputResidual(cell,node,0)+res(node,0);
Residual(cell,node,1) = InputResidual(cell,node,1)+res(node,1);
if(numVecDims==3)
Residual(cell,node,2) = InputResidual(cell,node,2);
}
}
#else
Kokkos::parallel_for(StokesFOImplicitThicknessUpdateResid_Policy(0,workset.numCells),*this);
#endif
}
void XZScalarAdvectionResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
std::vector<ScalarT> vel(2);
for (std::size_t i=0; i < Residual.size(); ++i) Residual(i)=0.0;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
if (coordVec(cell,qp,1) > 0.5) vel[0] = Re;
else vel[0] = 0.0;
vel[1] = 0.0;
for (std::size_t node=0; node < numNodes; ++node) {
// Transient Term
Residual(cell,node) += rhoDot(cell,qp)*wBF(cell,node,qp);
// Advection Term
for (std::size_t j=0; j < numDims; ++j) {
Residual(cell,node) += vel[j]*rhoGrad(cell,qp,j)*wBF(cell,node,qp);
}
}
}
}
}
void XZScalarAdvectionResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
// Constants
L = 2.5e6 // Latent Heat J/kg
cp = 1004.64 // Specfic Heat J/kg/K
std::vector<ScalarT> vel(2);
for (std::size_t i=0; i < Residual.size(); ++i) Residual(i)=0.0;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
if (coordVec(cell,qp,1) > 5.0) vel[0] = Re;
else vel[0] = 0.0;
vel[1] = 0.0;
for (std::size_t node=0; node < numNodes; ++node) {
// Transient Term
// Residual(cell,node) += rhoDot(cell,qp)*wBF(cell,node,qp);
Residual(cell,node,0) += rhoDot(cell,qp)*wBF(cell,node,qp);
Residual(cell,node,1) += tempDot(cell,qp)*wBF(cell,node,qp);
Residual(cell,node,2) += qvDot(cell,qp)*wBF(cell,node,qp);
Residual(cell,node,3) += qcDot(cell,qp)*wBF(cell,node,qp);
// Compute saturation mixing ratio for condensation rate with Teton's formula
// Saturation vapor pressure, temp in Celcius, equation valid over [-35,35] with a 3% error
qvs = 3.8 / rhoDot(cell,qp) * exp(17.27 * (tempGrad(cell,qp) - 273.)/(tempGrad(cell,qp) - 36.));
C = max( (qvDot(cell,qp) - qvs)/( 1. + qvs*((4093.*L)/(cp*tempDot(cell,qp)-36.)^2.) ) , -qcDot(cell,qp) );
Tv = T * (1 + 0.6*qv);
// Advection Term
for (std::size_t j=0; j < numDims; ++j) {
Residual(cell,node,0) += vel[j]*rhoGrad(cell,qp,j)*wBF(cell,node,qp);
Residual(cell,node,1) += vel[j]*tempGrad(cell,qp,j)*wBF(cell,node,qp)+L/cp*C;
Residual(cell,node,2) += vel[j]*qvGrad(cell,qp,j)*wBF(cell,node,qp)-C;
Residual(cell,node,3) += vel[j]*qcGrad(cell,qp,j)*wBF(cell,node,qp)+C;
}
}
}
}
}
void HydrideWResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools<PHX::Device> FST;
FST::integrate(wResidual.get_view(), wGrad.get_view(), wGradBF.get_view(), false); // "false" overwrites
if(!lump){
// Consistent mass matrix, the Intrepid2 way
FST::integrate(wResidual.get_view(), cDot.get_view(), wBF.get_view(), true); // "true" sums into
// Consistent mass matrix, done manually
/*
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)
wResidual(cell, node) += cDot(cell, qp) * wBF(cell, node, qp);
*/
}
else {
ScalarT diag;
// Lumped mass matrix
for (std::size_t cell=0; cell < workset.numCells; ++cell)
for (std::size_t qp=0; qp < numQPs; ++qp) {
diag = 0;
for (std::size_t node=0; node < numNodes; ++node)
diag += BF(cell, node, qp); // lump all the row onto the diagonal
for (std::size_t node=0; node < numNodes; ++node)
wResidual(cell, node) += diag * cDotNode(cell, node) * wBF(cell, node, qp);
}
}
}
void
TLPoroPlasticityResidMomentum<EvalT, Traits>::evaluateFields(
typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools<PHX::Device> FST;
typedef Intrepid2::RealSpaceTools<PHX::Device> RST;
RST::inverse(F_inv, defgrad.get_view());
RST::transpose(F_invT, F_inv);
FST::scalarMultiplyDataData(JF_invT, J.get_view(), F_invT);
// FST::tensorMultiplyDataData(P.get_view(), TotalStress.get_view(), JF_invT);
for (int cell = 0; cell < workset.numCells; ++cell) {
for (int node = 0; node < numNodes; ++node) {
for (int dim = 0; dim < numDims; dim++) ExResidual(cell, node, dim) = 0.0;
for (int qp = 0; qp < numQPs; ++qp) {
for (int i = 0; i < numDims; i++) {
for (int dim = 0; dim < numDims; dim++) {
ExResidual(cell, node, i) +=
TotalStress(cell, qp, i, dim) * wGradBF(cell, node, qp, dim);
}
}
}
}
}
if (workset.transientTerms && enableTransient)
for (int cell = 0; cell < workset.numCells; ++cell) {
for (int node = 0; node < numNodes; ++node) {
for (int qp = 0; qp < numQPs; ++qp) {
for (int i = 0; i < numDims; i++) {
ExResidual(cell, node, i) +=
uDotDot(cell, qp, i) * wBF(cell, node, qp);
}
}
}
}
// FST::integrate(ExResidual.get_view(), TotalStress.get_view(),
// wGradBF.get_view(), false); // "false" overwrites
}
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 NSMomentumResid<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) {
for (std::size_t i=0; i<numDims; i++) {
MResidual(cell,node,i) = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
MResidual(cell,node,i) +=
(Rm(cell, qp, i)-pGrad(cell,qp,i))*wBF(cell,node,qp) -
P(cell,qp)*wGradBF(cell,node,qp,i);
for (std::size_t j=0; j < numDims; ++j) {
MResidual(cell,node,i) +=
mu(cell,qp)*(VGrad(cell,qp,i,j)+VGrad(cell,qp,j,i))*wGradBF(cell,node,qp,j);
// mu(cell,qp)*VGrad(cell,qp,i,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
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 i=0; i<numDims; i++) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t j=0; j < numDims; ++j) {
MResidual(cell,node,i) +=
rho(cell,qp)*TauM(cell,qp)*Rm(cell,qp,j)*V(cell,qp,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
}
}
void PNP::PotentialResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools FST;
// Scale gradient into a flux, reusing same memory
FST::scalarMultiplyDataData<ScalarT> (PotentialGrad, Permittivity, PotentialGrad);
FST::integrate<ScalarT>(PotentialResidual, PotentialGrad, wGradBF, Intrepid2::COMP_CPP, false); // "false" overwrites
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 < numSpecies; ++j) {
PotentialResidual(cell,node) -=
q[j]*Concentration(cell,qp,j)*wBF(cell,node,qp);
//cout << "XXX " << cell << " " << node << " " << qp << " " << j << " " << q[j] << " " << Concentration(cell,qp,j) << endl;
}
}
}
}
}
void StokesMomentumResid<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) {
for (std::size_t i=0; i<numDims; i++) {
MResidual(cell,node,i) = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
MResidual(cell,node,i) +=
force(cell,qp,i)*wBF(cell,node,qp) -
P(cell,qp)*wGradBF(cell,node,qp,i);
for (std::size_t j=0; j < numDims; ++j) {
MResidual(cell,node,i) +=
muFELIX(cell,qp)*(VGrad(cell,qp,i,j)+VGrad(cell,qp,j,i))*wGradBF(cell,node,qp,j);
// muFELIX(cell,qp)*VGrad(cell,qp,i,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
}
void XZHydrostatic_TemperatureResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
PHAL::set(Residual, 0.0);
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
for (int qp=0; qp < numQPs; ++qp) {
for (int dim=0; dim < numDims; ++dim)
Residual(cell,node,level) += velx(cell,qp,level,dim)*temperatureGrad(cell,qp,level,dim)*wBF(cell,node,qp);
Residual(cell,node,level) += temperatureSrc(cell,qp,level) *wBF(cell,node,qp);
Residual(cell,node,level) -= omega(cell,qp,level) *wBF(cell,node,qp);
Residual(cell,node,level) += etadotdT(cell,qp,level) *wBF(cell,node,qp);
Residual(cell,node,level) += temperatureDot(cell,qp,level) *wBF(cell,node,qp);
}
}
}
}
}
void ReactDiffSystemResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools<PHX::Device> FST;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t i=0; i<vecDim; i++) Residual(cell,node,i) = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
//- mu0*delta(u0) + a0*u0 + a1*u1 + a2*u2 = f0
Residual(cell,node,0) += mu0*UGrad(cell,qp,0,0)*wGradBF(cell,node,qp,0) +
mu0*UGrad(cell,qp,0,1)*wGradBF(cell,node,qp,1) +
mu0*UGrad(cell,qp,0,2)*wGradBF(cell,node,qp,2) -
reactCoeff0[0]*U(cell,qp,0)*wBF(cell,node,qp) -
reactCoeff0[1]*U(cell,qp,1)*wBF(cell,node,qp) -
reactCoeff0[2]*U(cell,qp,2)*wBF(cell,node,qp) -
forces[0]*wBF(cell,node,qp);
//- mu1*delta(u1) + b0*u0 + b1*u1 + b2*u2 = f1
Residual(cell,node,1) += mu1*UGrad(cell,qp,1,0)*wGradBF(cell,node,qp,0) +
mu1*UGrad(cell,qp,1,1)*wGradBF(cell,node,qp,1) +
mu1*UGrad(cell,qp,1,2)*wGradBF(cell,node,qp,2) -
reactCoeff1[0]*U(cell,qp,0)*wBF(cell,node,qp) -
reactCoeff1[1]*U(cell,qp,1)*wBF(cell,node,qp) -
reactCoeff1[2]*U(cell,qp,2)*wBF(cell,node,qp) -
forces[1]*wBF(cell,node,qp);
//- mu2*delta(u2) + c0*u0 + c1*u1 + c2*u2 = f2
Residual(cell,node,2) += mu2*UGrad(cell,qp,2,0)*wGradBF(cell,node,qp,0) +
mu2*UGrad(cell,qp,2,1)*wGradBF(cell,node,qp,1) +
mu2*UGrad(cell,qp,2,2)*wGradBF(cell,node,qp,2) -
reactCoeff2[0]*U(cell,qp,0)*wBF(cell,node,qp) -
reactCoeff2[1]*U(cell,qp,1)*wBF(cell,node,qp) -
reactCoeff2[2]*U(cell,qp,2)*wBF(cell,node,qp) -
forces[2]*wBF(cell,node,qp);
}
}
}
}
KOKKOS_INLINE_FUNCTION
void XZHydrostatic_VelResid<EvalT, Traits>::
operator() (const XZHydrostatic_VelResid_Tag& tag, const int& cell) const{
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
for (int dim=0; dim < numDims; ++dim) {
int qp = node;
Residual(cell,node,level,dim) = ( keGrad(cell,qp,level,dim) + PhiGrad(cell,qp,level,dim) )*wBF(cell,node,qp)
+ ( pGrad (cell,qp,level,dim)/density(cell,qp,level) ) *wBF(cell,node,qp)
+ etadotdVelx(cell,qp,level,dim) *wBF(cell,node,qp)
+ uDot(cell,qp,level,dim) *wBF(cell,node,qp);
for (int qp=0; qp < numQPs; ++qp) {
Residual(cell,node,level,dim) += viscosity * DVelx(cell,qp,level,dim) * wGradBF(cell,node,qp,dim);
}
}
}
}
}
void XZHydrostatic_VelResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
#ifndef ALBANY_KOKKOS_UNDER_DEVELOPMENT
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
for (int dim=0; dim < numDims; ++dim) {
int qp = node;
Residual(cell,node,level,dim) = ( keGrad(cell,qp,level,dim) + PhiGrad(cell,qp,level,dim) )*wBF(cell,node,qp)
+ ( pGrad (cell,qp,level,dim)/density(cell,qp,level) ) *wBF(cell,node,qp)
+ etadotdVelx(cell,qp,level,dim) *wBF(cell,node,qp)
+ uDot(cell,qp,level,dim) *wBF(cell,node,qp);
for (int qp=0; qp < numQPs; ++qp) {
Residual(cell,node,level,dim) += viscosity * DVelx(cell,qp,level,dim) * wGradBF(cell,node,qp,dim);
}
}
}
}
}
#else
Kokkos::parallel_for(XZHydrostatic_VelResid_Policy(0,workset.numCells),*this);
#endif
}
void StokesFOResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
for (std::size_t i=0; i < Residual.size(); ++i) Residual(i)=0.0;
if (numDims == 3) { //3D case
if (eqn_type == FELIX) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
ScalarT& mu = muFELIX(cell,qp);
ScalarT strs00 = 2.0*mu*(2.0*Ugrad(cell,qp,0,0) + Ugrad(cell,qp,1,1));
ScalarT strs11 = 2.0*mu*(2.0*Ugrad(cell,qp,1,1) + Ugrad(cell,qp,0,0));
ScalarT strs01 = mu*(Ugrad(cell,qp,1,0)+ Ugrad(cell,qp,0,1));
ScalarT strs02 = mu*Ugrad(cell,qp,0,2);
ScalarT strs12 = mu*Ugrad(cell,qp,1,2);
for (std::size_t node=0; node < numNodes; ++node) {
Residual(cell,node,0) += strs00*wGradBF(cell,node,qp,0) +
strs01*wGradBF(cell,node,qp,1) +
strs02*wGradBF(cell,node,qp,2);
Residual(cell,node,1) += strs01*wGradBF(cell,node,qp,0) +
strs11*wGradBF(cell,node,qp,1) +
strs12*wGradBF(cell,node,qp,2);
}
}
for (std::size_t qp=0; qp < numQPs; ++qp) {
ScalarT& frc0 = force(cell,qp,0);
ScalarT& frc1 = force(cell,qp,1);
for (std::size_t node=0; node < numNodes; ++node) {
Residual(cell,node,0) += frc0*wBF(cell,node,qp);
Residual(cell,node,1) += frc1*wBF(cell,node,qp);
}
}
} }
else if (eqn_type == POISSON) { //Laplace (Poisson) operator
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) {
Residual(cell,node,0) += Ugrad(cell,qp,0,0)*wGradBF(cell,node,qp,0) +
Ugrad(cell,qp,0,1)*wGradBF(cell,node,qp,1) +
Ugrad(cell,qp,0,2)*wGradBF(cell,node,qp,2) +
force(cell,qp,0)*wBF(cell,node,qp);
}
} } }
}
else { //2D case
if (eqn_type == FELIX) {
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) {
Residual(cell,node,0) += 2.0*muFELIX(cell,qp)*((2.0*Ugrad(cell,qp,0,0) + Ugrad(cell,qp,1,1))*wGradBF(cell,node,qp,0) +
0.5*(Ugrad(cell,qp,0,1) + Ugrad(cell,qp,1,0))*wGradBF(cell,node,qp,1)) +
force(cell,qp,0)*wBF(cell,node,qp);
Residual(cell,node,1) += 2.0*muFELIX(cell,qp)*(0.5*(Ugrad(cell,qp,0,1) + Ugrad(cell,qp,1,0))*wGradBF(cell,node,qp,0) +
(Ugrad(cell,qp,0,0) + 2.0*Ugrad(cell,qp,1,1))*wGradBF(cell,node,qp,1)) + force(cell,qp,1)*wBF(cell,node,qp);
}
} } }
else if (eqn_type == POISSON) { //Laplace (Poisson) operator
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) {
Residual(cell,node,0) += Ugrad(cell,qp,0,0)*wGradBF(cell,node,qp,0) +
Ugrad(cell,qp,0,1)*wGradBF(cell,node,qp,1) +
force(cell,qp,0)*wBF(cell,node,qp);
}
} } }
}
}
void ComputeHierarchicBasis<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
// do some work to get the pumi discretization and the apf mesh
// this is so we can use the pumi mesh database to compute
// mesh / basis function quantities.
Teuchos::RCP<Albany::AbstractDiscretization> discretization =
app->getDiscretization();
Teuchos::RCP<Albany::PUMIDiscretization> pumiDiscretization =
Teuchos::rcp_dynamic_cast<Albany::PUMIDiscretization>(discretization);
Teuchos::RCP<Albany::PUMIMeshStruct> pumiMeshStruct =
pumiDiscretization->getPUMIMeshStruct();
// get the element block index
// this will allow us to index into buckets
ebIndex = pumiMeshStruct->ebNameToIndex[workset.EBName];
// get the buckets
// this is the elements of the apf mesh indexed by
// buckets[Elem Block Index][Cell Index]
buckets = pumiDiscretization->getBuckets();
// get the apf mesh
// this is used for a variety of apf things
mesh = pumiMeshStruct->getMesh();
// get the apf heirarchic shape
// this is used to get shape function values / gradients
shape = apf::getHierarchic(polynomialOrder);
for (int cell=0; cell < workset.numCells; ++cell)
{
// get the apf objects associated with this cell
apf::MeshEntity* element = buckets[ebIndex][cell];
apf::MeshElement* meshElement = apf::createMeshElement(mesh, element);
for (int qp=0; qp < numQPs; ++qp)
{
// get the parametric value of the current integration point
apf::getIntPoint(meshElement, cubatureDegree, qp, point);
// set the jacobian determinant
detJ(cell, qp) = apf::getDV(meshElement, point);
assert( detJ(cell, qp) > 0.0 );
// get the integration point weight associated with this qp
double w = apf::getIntWeight(meshElement, cubatureDegree, qp);
// weight the determinant of the jacobian by the qp weight
weightedDV(cell, qp) = w * detJ(cell,qp);
// get the shape function values and gradients at this point
apf::getBF(shape, meshElement, point, bf);
apf::getGradBF(shape, meshElement, point, gbf);
for (int node=0; node < numNodes; ++node)
{
BF(cell, node, qp) = bf[node];
wBF(cell, node, qp) = weightedDV(cell, qp) * bf[node];
for (int dim=0; dim < numDims; ++dim)
{
GradBF(cell, node, qp, dim) = gbf[node][dim];
wGradBF(cell, node, qp, dim) = weightedDV(cell,qp) * gbf[node][dim];
}
}
}
// do some memory cleanup to keep everyone happy
apf::destroyMeshElement(meshElement);
}
}
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) );
}
}
}
}
}
