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) ); } } } } }