void BiotModulus<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
int numCells = workset.numCells;
if (is_constant) {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
biotModulus(cell,qp) = constant_value;
}
}
}
else {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
Teuchos::Array<MeshScalarT> point(numDims);
for (int i=0; i<numDims; i++)
point[i] = Sacado::ScalarValue<MeshScalarT>::eval(coordVec(cell,qp,i));
biotModulus(cell,qp) = exp_rf_kl->evaluate(point, rv);
}
}
}
if (isPoroElastic) {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
// 1/M = (B-phi)/Ks + phi/Kf
biotModulus(cell,qp) = 1/((biotCoefficient(cell,qp) - porosity(cell,qp))/GrainBulkModulus
+ porosity(cell,qp)/FluidBulkModulus);
}
}
}
}
void KCPermeability<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
std::size_t numCells = workset.numCells;
if (is_constant) {
for (std::size_t cell=0; cell < numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
kcPermeability(cell,qp) = constant_value;
}
}
}
else {
for (std::size_t cell=0; cell < numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
Teuchos::Array<MeshScalarT> point(numDims);
for (std::size_t i=0; i<numDims; i++)
point[i] = Sacado::ScalarValue<MeshScalarT>::eval(coordVec(cell,qp,i));
kcPermeability(cell,qp) = exp_rf_kl->evaluate(point, rv);
}
}
}
if (isPoroElastic) {
for (std::size_t cell=0; cell < numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
// Cozeny Karman permeability equation
kcPermeability(cell,qp) = constant_value*porosity(cell,qp)*porosity(cell,qp)*porosity(cell,qp)/
(1-porosity(cell,qp)*porosity(cell,qp));
}
}
}
}
void
MixtureThermalExpansion<EvalT, Traits>::evaluateFields(
typename Traits::EvalData workset)
{
// Compute Strain tensor from displacement gradient
for (int cell = 0; cell < workset.numCells; ++cell) {
for (int qp = 0; qp < numQPs; ++qp) {
mixtureThermalExpansion(cell, qp) =
(biotCoefficient(cell, qp) * J(cell, qp) - porosity(cell, qp)) *
alphaSkeleton(cell, qp) +
porosity(cell, qp) * alphaPoreFluid(cell, qp);
}
}
}
int main(int argc, char *argv[])
{
vector *e, *xf, *phi;
matrix *out;
int i, n=100;
double ei, xfi, phii, X0 = .33;
e = linspaceV(0, -.3, n);
xf = CreateVector(n);
phi = CreateVector(n);
for(i=0; i<n; i++) {
ei = valV(e, i);
xfi = solidfrac(X0, 300, ei);
phii = porosity(X0, .15, 300, ei);
setvalV(xf, i, xfi);
setvalV(phi, i, phii);
}
out = CatColVector(3, e, xf, phi);
mtxprntfilehdr(out, "output.csv", "strain,solidfrac,porosity\n");
return;
}
void MixtureSpecificHeat<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
// Compute Strain tensor from displacement gradient
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
mixtureSpecificHeat(cell,qp) = (J(cell,qp)-porosity(cell,qp))
*gammaSkeleton(cell,qp)*densitySkeleton(cell,qp) +
porosity(cell,qp)*gammaPoreFluid(cell,qp)*
densityPoreFluid(cell,qp);
}
}
}
void EquivalentInclusionConductivity<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
int numCells = workset.numCells;
if (is_constant) {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
effectiveK(cell,qp) = constant_value;
}
}
}
#ifdef ALBANY_STOKHOS
else {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
Teuchos::Array<MeshScalarT> point(numDims);
for (int i=0; i<numDims; i++)
point[i] = Sacado::ScalarValue<MeshScalarT>::eval(coordVec(cell,qp,i));
effectiveK(cell,qp) = exp_rf_kl->evaluate(point, rv);
}
}
}
#endif
if (isPoroElastic) {
for (int cell=0; cell < numCells; ++cell) {
for (int qp=0; qp < numQPs; ++qp) {
effectiveK(cell,qp) = porosity(cell,qp)*condKf +
(J(cell,qp)-porosity(cell,qp))*condKs;
// effectiveK(cell,qp) = condKf
// + ( J(cell,qp) - porosity(cell,qp))*
// (condKs - condKf)*condKf/
// ((condKs - condKf)*porosity(cell,qp)
// + J(cell,qp)*condKf);
}
}
}
}
// Construct from components
centreVoidFraction::centreVoidFraction
(
const dictionary& dict,
cfdemCloud& sm
)
:
voidFractionModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
alphaMin_(readScalar(propsDict_.lookup("alphaMin"))),
alphaLimited_(0)
{
checkWeightNporosity(propsDict_);
if(porosity()!=1) FatalError << "porosity not used in centreVoidFraction" << abort(FatalError);
}
int main(int argc, char *argv[])
{
vector *Xe, *phi1, *phi2, *phi3;
matrix *out;
int i, n=100;
double Xei, phii, X0 = .33,
T1=313, T2=333, T3=353,
type=3,
coef=-1;
Xe = linspaceV(0, .3, n);
phi1 = CreateVector(n);
phi2 = CreateVector(n);
phi3 = CreateVector(n);
for(i=0; i<n; i++) {
Xei = valV(Xe, i);
phii = porosity(X0, Xei, T1, coef*(1-pow(exp_strain_lin(Xei-X0, T1),type)));
//phii = exp_strain(Xei-X0, T1);
setvalV(phi1, i, phii);
phii = porosity(X0, Xei, T2, coef*(1-pow(exp_strain_lin(Xei-X0, T2),type)));
//phii = exp_strain(Xei-X0, T2);
setvalV(phi2, i, phii);
phii = porosity(X0, Xei, T3, coef*(1-pow(exp_strain_lin(Xei-X0, T3),type)));
//phii = exp_strain(Xei-X0, T3);
setvalV(phi3, i, phii);
}
out = CatColVector(4, Xe, phi1, phi2, phi3);
mtxprntfilehdr(out, "output.csv", "Xe,phi313,phi333,phi353\n");
return;
}
void Foam::porousZone::writeDict(Ostream& os, bool subDict) const
{
if (subDict)
{
os << indent << token::BEGIN_BLOCK << incrIndent << nl;
os.writeKeyword("name") << zoneName() << token::END_STATEMENT << nl;
}
else
{
os << indent << zoneName() << nl
<< indent << token::BEGIN_BLOCK << incrIndent << nl;
}
if (dict_.found("note"))
{
os.writeKeyword("note") << string(dict_.lookup("note"))
<< token::END_STATEMENT << nl;
}
coordSys_.writeDict(os, true);
if (dict_.found("porosity"))
{
os.writeKeyword("porosity") << porosity() << token::END_STATEMENT << nl;
}
// powerLaw coefficients
if (const dictionary* dictPtr = dict_.subDictPtr("powerLaw"))
{
os << indent << "powerLaw";
dictPtr->write(os);
}
// Darcy-Forchheimer coefficients
if (const dictionary* dictPtr = dict_.subDictPtr("Darcy"))
{
os << indent << "Darcy";
dictPtr->write(os);
}
os << decrIndent << indent << token::END_BLOCK << endl;
}
int main(int argc, char *argv[])
{
vector *Xdb, *strain, *stress, *Pc, *phi, *aw, *xf;
double Xmin = .05,
Xmax = .29,
Xi = .33,
T,
n = 100;
matrix *output;
int i;
oswin *o;
if(argc != 2) {
puts("Usage: calc-stress <T>");
puts(" <T>: Temperature in Kelvins");
exit(0);
}
T = atof(argv[1]);
o = CreateOswinData();
Xdb = linspaceV(Xmin, Xmax, n);
strain = CreateVector(n);
stress = CreateVector(n);
phi = CreateVector(n);
aw = CreateVector(n);
Pc = CreateVector(n);
xf = CreateVector(n);
for(i=0; i<n; i++) {
setvalV(strain, i, linear_strain(Xi, valV(Xdb, i), T));
setvalV(stress, i,
valV(strain, i)*EaLaura(T, valV(Xdb, i)));
setvalV(Pc, i, EffPorePress(Xi, valV(Xdb, i), T));
setvalV(aw, i, OswinInverse(o, valV(Xdb, i), T));
setvalV(xf, i, solidfrac(Xi, T, valV(strain, i)));
setvalV(phi, i, porosity(Xi, valV(Xdb, i), T, valV(strain, i)));
}
output = CatColVector(7, Xdb, strain, stress, Pc, aw, xf, phi);
mtxprntfilehdr(output, "stress.csv", "Xdb,strain,stress,Pc,aw,solidfrac,porosity\n");
}
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 )
);
}
}
}
}
