void DruckerPragerModel<EvalT, Traits>::
computeState(typename Traits::EvalData workset,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > dep_fields,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > eval_fields)
{
// extract dependent MDFields
PHX::MDField<ScalarT> strain = *dep_fields["Strain"];
PHX::MDField<ScalarT> poissons_ratio = *dep_fields["Poissons Ratio"];
PHX::MDField<ScalarT> elastic_modulus = *dep_fields["Elastic Modulus"];
// retrieve appropriate field name strings
std::string cauchy_string = (*field_name_map_)["Cauchy_Stress"];
std::string strain_string = (*field_name_map_)["Strain"];
std::string eqps_string = (*field_name_map_)["eqps"];
std::string friction_string = (*field_name_map_)["Friction_Parameter"];
// extract evaluated MDFields
PHX::MDField<ScalarT> stress = *eval_fields[cauchy_string];
PHX::MDField<ScalarT> eqps = *eval_fields[eqps_string];
PHX::MDField<ScalarT> friction = *eval_fields[friction_string];
PHX::MDField<ScalarT> tangent = *eval_fields["Material Tangent"];
// get State Variables
Albany::MDArray strainold = (*workset.stateArrayPtr)[strain_string + "_old"];
Albany::MDArray stressold = (*workset.stateArrayPtr)[cauchy_string + "_old"];
Albany::MDArray eqpsold = (*workset.stateArrayPtr)[eqps_string + "_old"];
Albany::MDArray frictionold = (*workset.stateArrayPtr)[friction_string + "_old"];
Intrepid::Tensor<ScalarT> id(Intrepid::eye<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id1(Intrepid::identity_1<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id2(Intrepid::identity_2<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id3(Intrepid::identity_3<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> Celastic (num_dims_);
Intrepid::Tensor<ScalarT> sigma(num_dims_), sigmaN(num_dims_), s(num_dims_);
Intrepid::Tensor<ScalarT> epsilon(num_dims_), epsilonN(num_dims_);
Intrepid::Tensor<ScalarT> depsilon(num_dims_);
Intrepid::Tensor<ScalarT> nhat(num_dims_);
ScalarT lambda, mu, kappa;
ScalarT alpha, alphaN;
ScalarT p, q, ptr, qtr;
ScalarT eq, eqN, deq;
ScalarT snorm;
ScalarT Phi;
//local unknowns and residual vectors
std::vector<ScalarT> X(4);
std::vector<ScalarT> R(4);
std::vector<ScalarT> dRdX(16);
for (std::size_t cell(0); cell < workset.numCells; ++cell) {
for (std::size_t pt(0); pt < num_pts_; ++pt) {
lambda = ( elastic_modulus(cell,pt) * poissons_ratio(cell,pt) )
/ ( ( 1 + poissons_ratio(cell,pt) ) * ( 1 - 2 * poissons_ratio(cell,pt) ) );
mu = elastic_modulus(cell,pt) / ( 2 * ( 1 + poissons_ratio(cell,pt) ) );
kappa = lambda + 2.0 * mu / 3.0;
// 4-th order elasticity tensor
Celastic = lambda * id3 + mu * (id1 + id2);
// previous state (the fill doesn't work for state virable)
//sigmaN.fill( &stressold(cell,pt,0,0) );
//epsilonN.fill( &strainold(cell,pt,0,0) );
for (std::size_t i(0); i < num_dims_; ++i) {
for (std::size_t j(0); j < num_dims_; ++j) {
sigmaN(i, j) = stressold(cell, pt, i, j);
epsilonN(i, j) = strainold(cell, pt, i, j);
//epsilon(i,j) = strain(cell,pt,i,j);
}
}
epsilon.fill( &strain(cell,pt,0,0) );
depsilon = epsilon - epsilonN;
alphaN = frictionold(cell,pt);
eqN = eqpsold(cell,pt);
// trial state
sigma = sigmaN + Intrepid::dotdot(Celastic,depsilon);
ptr = Intrepid::trace(sigma) / 3.0;
s = sigma - ptr * id;
snorm = Intrepid::dotdot(s,s);
if(snorm > 0) snorm = std::sqrt(snorm);
qtr = sqrt(3.0/2.0) * snorm;
// unit deviatoric tensor
if (snorm > 0){
nhat = s / snorm;
} else{
nhat = id;
}
// check yielding
Phi = qtr + alphaN * ptr - Cf_;
alpha = alphaN;
p = ptr;
q = qtr;
deq = 0.0;
if(Phi > 1.0e-12) {// plastic yielding
// initialize local unknown vector
X[0] = ptr;
X[1] = qtr;
X[2] = alpha;
X[3] = deq;
LocalNonlinearSolver<EvalT, Traits> solver;
int iter = 0;
ScalarT norm_residual0(0.0), norm_residual(0.0), relative_residual(0.0);
// local N-R loop
while (true) {
ResidualJacobian(X, R, dRdX, ptr, qtr, eqN, mu, kappa);
norm_residual = 0.0;
for (int i = 0; i < 4; i++)
norm_residual += R[i] * R[i];
norm_residual = std::sqrt(norm_residual);
if (iter == 0)
norm_residual0 = norm_residual;
if (norm_residual0 != 0)
relative_residual = norm_residual / norm_residual0;
else
relative_residual = norm_residual0;
//std::cout << iter << " "
//<< Sacado::ScalarValue<ScalarT>::eval(norm_residual)
//<< " " << Sacado::ScalarValue<ScalarT>::eval(relative_residual)
//<< std::endl;
if (relative_residual < 1.0e-11 || norm_residual < 1.0e-11)
break;
if (iter > 20)
break;
// call local nonlinear solver
solver.solve(dRdX, X, R);
iter++;
} // end of local N-R loop
// compute sensitivity information w.r.t. system parameters
// and pack the sensitivity back to X
solver.computeFadInfo(dRdX, X, R);
// update
p = X[0];
q = X[1];
alpha = X[2];
deq = X[3];
}//end plastic yielding
eq = eqN + deq;
s = sqrt(2.0/3.0) * q * nhat;
sigma = s + p * id;
eqps(cell, pt) = eq;
friction(cell,pt) = alpha;
for (std::size_t i(0); i < num_dims_; ++i) {
for (std::size_t j(0); j < num_dims_; ++j) {
stress(cell,pt,i,j) = sigma(i, j);
}
}
}// end loop over pt
} // end loop over cell
}
// Right-hand side for hyperbolic PDE in divergence form
//
// q_t = -( f(q,x,y,t)_x + g(q,x,y,t)_y ) + Psi(q,x,y,t)
//
void LaxWendroff_Unst(double dt,
const mesh& Mesh, const edge_data_Unst& EdgeData,
dTensor3& aux, // SetBndValues modifies ghost cells
dTensor3& q, // SetBndValues modifies ghost cells
dTensor3& Lstar, dTensor1& smax)
{
const int NumElems = Mesh.get_NumElems();
const int NumPhysElems = Mesh.get_NumPhysElems();
const int NumEdges = Mesh.get_NumEdges();
const int meqn = q.getsize(2);
const int kmax = q.getsize(3);
const int maux = aux.getsize(2);
const int space_order = dogParams.get_space_order();
dTensor3 EdgeFluxIntegral(NumElems,meqn,kmax);
dTensor3 ElemFluxIntegral(NumElems,meqn,kmax);
dTensor3 Psi(NumElems,meqn,kmax);
// ---------------------------------------------------------
// Boundary Conditions
SetBndValues_Unst(Mesh, &q, &aux);
// ---------------------------------------------------------
// --------------------------------------------------------------------- //
// Part 0: Compute the Lax-Wendroff "flux" function:
//
// Here, we include the extra information about time derivatives.
// --------------------------------------------------------------------- //
dTensor3 F(NumElems, meqn, kmax ); F.setall(0.);
dTensor3 G(NumElems, meqn, kmax ); G.setall(0.);
L2ProjectLxW_Unst( dogParams.get_time_order(), 1.0, 0.5*dt, dt*dt/6.0, 1, NumElems,
space_order, space_order, space_order, space_order, Mesh,
&q, &aux, &F, &G, &FluxFunc, &DFluxFunc, &D2FluxFunc );
// ---------------------------------------------------------
// Part I: compute source term
// ---------------------------------------------------------
if ( dogParams.get_source_term()>0 )
{
// eprintf("error: have not implemented source term for LxW solver.");
printf("Source term has not been implemented for LxW solver. Terminating program.");
exit(1);
}
Lstar.setall(0.);
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part II: compute flux integral on element edges
// ---------------------------------------------------------
// Loop over all interior edges
EdgeFluxIntegral.setall(0.);
ElemFluxIntegral.setall(0.);
#pragma omp parallel for
// Loop over all interior edges
for (int i=1; i<=NumEdges; i++)
{
// Edge coordinates
double x1 = Mesh.get_edge(i,1);
double y1 = Mesh.get_edge(i,2);
double x2 = Mesh.get_edge(i,3);
double y2 = Mesh.get_edge(i,4);
// Elements on either side of edge
int ileft = Mesh.get_eelem(i,1);
int iright = Mesh.get_eelem(i,2);
double Areal = Mesh.get_area_prim(ileft);
double Arear = Mesh.get_area_prim(iright);
// Scaled normal to edge
dTensor1 nhat(2);
nhat.set(1, (y2-y1) );
nhat.set(2, (x1-x2) );
// Variables to store flux integrals along edge
dTensor2 Fr_tmp(meqn,dogParams.get_space_order());
dTensor2 Fl_tmp(meqn,dogParams.get_space_order());
// Loop over number of quadrature points along each edge
for (int ell=1; ell<=dogParams.get_space_order(); ell++)
{
dTensor1 Ql(meqn), Qr(meqn);
dTensor1 ffl(meqn), ffr(meqn); // << -- NEW PART -- >>
dTensor1 Auxl(maux), Auxr(maux);
// Riemann data - q
for (int m=1; m<=meqn; m++)
{
Ql.set(m, 0.0 );
Qr.set(m, 0.0 );
// << -- NEW PART, ffl and ffr -- >> //
ffl.set(m, 0.0 );
ffr.set(m, 0.0 );
for (int k=1; k<=kmax; k++)
{
Ql.set(m, Ql.get(m) + EdgeData.phi_left->get(i,ell,k)
*q.get(ileft, m,k) );
Qr.set(m, Qr.get(m) + EdgeData.phi_right->get(i,ell,k)
*q.get(iright,m,k) );
// << -- NEW PART, ffl and ffr -- >> //
// Is this the correct way to use the normal vector?
ffl.set(m, ffl.get(m) + EdgeData.phi_left->get (i, ell, k) * (
nhat.get(1)*F.get( ileft, m, k) + nhat.get(2)*G.get( ileft, m, k) ) );
ffr.set(m, ffr.get(m) + EdgeData.phi_right->get(i, ell, k) * (
nhat.get(1)*F.get(iright, m, k) + nhat.get(2)*G.get(iright, m, k) ) );
}
}
// Riemann data - aux
for (int m=1; m<=maux; m++)
{
Auxl.set(m, 0.0 );
Auxr.set(m, 0.0 );
for (int k=1; k<=kmax; k++)
{
Auxl.set(m, Auxl.get(m) + EdgeData.phi_left->get(i,ell,k) * aux.get(ileft, m,k) );
Auxr.set(m, Auxr.get(m) + EdgeData.phi_right->get(i,ell,k) * aux.get(iright,m,k) );
}
}
// Solve Riemann problem
dTensor1 xedge(2);
double s = EdgeData.xpts1d->get(ell);
xedge.set(1, x1 + 0.5*(s+1.0)*(x2-x1) );
xedge.set(2, y1 + 0.5*(s+1.0)*(y2-y1) );
// Solve the Riemann problem for this edge
dTensor1 Fl(meqn), Fr(meqn);
// Use the time-averaged fluxes to define left and right values for
// the Riemann solver.
const double smax_edge = RiemannSolveLxW(
nhat, xedge, Ql, Qr, Auxl, Auxr, ffl, ffr, Fl, Fr);
smax.set(i, Max(smax_edge,smax.get(i)) );
// Construct fluxes
for (int m=1; m<=meqn; m++)
{
Fr_tmp.set(m,ell, Fr.get(m) );
Fl_tmp.set(m,ell, Fl.get(m) );
}
}
// Add edge integral to line integral around the full element
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
double Fl_sum = 0.0;
double Fr_sum = 0.0;
for (int ell=1; ell<=dogParams.get_space_order(); ell++)
{
Fl_sum = Fl_sum + 0.5*EdgeData.wgts1d->get(ell)
*EdgeData.phi_left->get(i,ell,k) *Fl_tmp.get(m,ell);
Fr_sum = Fr_sum + 0.5*EdgeData.wgts1d->get(ell)
*EdgeData.phi_right->get(i,ell,k)*Fr_tmp.get(m,ell);
}
EdgeFluxIntegral.set(ileft, m,k, EdgeFluxIntegral.get(ileft, m,k) + Fl_sum/Areal );
EdgeFluxIntegral.set(iright,m,k, EdgeFluxIntegral.get(iright,m,k) - Fr_sum/Arear );
}
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part III: compute intra-element contributions
// ---------------------------------------------------------
if( dogParams.get_space_order() > 1 )
{
L2ProjectGradAddLegendre_Unst(1, NumPhysElems, space_order,
Mesh, &F, &G, &ElemFluxIntegral );
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part IV: construct Lstar
// ---------------------------------------------------------
if (dogParams.get_source_term()==0) // Without Source Term
{
#pragma omp parallel for
for (int i=1; i<=NumPhysElems; i++)
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
double tmp = ElemFluxIntegral.get(i,m,k) - EdgeFluxIntegral.get(i,m,k);
Lstar.set(i,m,k, tmp );
}
}
else // With Source Term
{
#pragma omp parallel for
for (int i=1; i<=NumPhysElems; i++)
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
// double tmp = ElemFluxIntegral.get(i,m,k)
// - EdgeFluxIntegral.get(i,m,k)
// + Psi.get(i,m,k);
// Lstar.set(i,m,k, tmp );
printf("Source term has not been implemented for LxW solver. Terminating program.");
exit(1);
}
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part V: add extra contributions to Lstar
// ---------------------------------------------------------
// Call LstarExtra
LstarExtra_Unst(Mesh, &q, &aux, &Lstar);
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part VI: artificial viscosity limiter
// ---------------------------------------------------------
// if (dogParams.get_space_order()>1 &&
// dogParams.using_viscosity_limiter())
// { ArtificialViscosity(&aux,&q,&Lstar); }
// ---------------------------------------------------------
}
void MeshEnergy::GetKappa( const std::vector<int>& C, const std::vector<double>& phi,
std::valarray<double>& kappa)
{
// kappa: divergence of normal
// dy^2 * dxx - 2dxdydxy + dx^2dyy / ( dx^2 + dy^2 )^(3/2)
vtkPoints* verts = meshdata->polydata->GetPoints();
for( ::size_t k_ = 0; k_ < C.size(); k_++ )\
{
int k = C[k_];
std::vector<double> nhat(3);
nhat[0] = meshdata->nx[k]; // these are normal to surface; the nx_ are the contour normals
nhat[1] = meshdata->ny[k];
nhat[2] = meshdata->nz[k];
// step 1. create the rotation matrix that orients the current normal as [0,0,1]'.
double phiang = atan2( nhat[0], nhat[1] );
std::vector<double> rotate1(9);
rotate1[0] = cos(phiang); rotate1[1] = -sin(phiang); rotate1[2] = 0;
rotate1[3] = sin(phiang); rotate1[4] = cos(phiang); rotate1[5] = 0;
rotate1[6] = 0; rotate1[7] = 0; rotate1[8] = 1.0;
std::vector<double> nhat_a(3);
pkmult( nhat, rotate1, nhat_a );
double ytilde = nhat_a[1];
double theta = M_PI_2 - atan2(nhat[2],ytilde);
std::vector<double> rotate2(9);
rotate2[0] = 1.0; rotate2[1] = 0; rotate2[2] = 0;
rotate2[3] = 0; rotate2[4] = cos(theta); rotate2[5] = -sin(theta);
rotate2[6] = 0; rotate2[7] = sin(theta); rotate2[8] = cos(theta);
std::vector<double> nhat_b(3);
pkmult( nhat_a, rotate2, nhat_b );
// nhat_b should now be [0 0 1]'
double thispt[3];
verts->GetPoint( k, thispt );
// apply rotate2 * rotate1 to each *translated* neighbor of this k-th point
::size_t num_neigh = meshdata->adj[k].myNeighbs.size();
double vec[3];
std::vector<double> vv(3);
std::vector<double> vv_(3);
std::valarray<double> xdata(num_neigh);
std::valarray<double> ydata(num_neigh);
std::valarray<double> zdata(num_neigh);
// step 2. create temporary set of std::vectors as copies of neighboring points
// translated to origin
// step 3. apply the rotation to all these points
for (::size_t i = 0; i < num_neigh; i++ )
{
int idx = meshdata->adj[k].myNeighbs[i];
verts->GetPoint( idx, vec );
vv[0] = vec[0] - thispt[0];
vv[1] = vec[1] - thispt[1];
vv[2] = vec[2] - thispt[2];
pkmult( vv, rotate1, vv_ );
pkmult( vv_, rotate2, vv );
xdata[i] = vv[0];
ydata[i] = vv[1];
zdata[i] = phi[idx] - phi[k]; //vv[2];
// zero reference phi at the vertex where we are forming tangent plane
}
/*if( abs(zdata).min() < 1e-6 )
continue;*/
// step 4. find first derivatives
double phi_x = 0.0;
double phi_y = 0.0;
{
std::valarray<double> RHS(2);
std::valarray<double> ATA(4);
ATA[0] = (xdata * xdata).sum();
ATA[1] = (xdata * ydata).sum();
ATA[2] = ATA[1];
ATA[3] = (ydata * ydata).sum();
RHS[0] = (xdata * zdata).sum();
RHS[1] = (ydata * zdata).sum();
int maxits = 1000;
std::valarray<double> ab = RHS; // initial guess
std::valarray<double> LHS(2);
pkmult2( ab, ATA, LHS );
double res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
double tol = 1e-8;
int iter = 0;
while( iter < maxits && res > tol )
{
iter++;
ab[0] = (RHS[0] - ( ab[1]*ATA[1] ) )/ ATA[0];
ab[1] = (RHS[1] - ( ab[0]*ATA[2] ) )/ ATA[3];
pkmult2( ab, ATA, LHS );
res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
}
phi_x = ab[0];
phi_y = ab[1];
}
// step 4. find least-squares fit for phi(x,y) = ax^2 + bxy + cy^2
// to get second derivatives
std::valarray<double> RHS(3); // A'z
RHS[0] = ( xdata * xdata * zdata ).sum();
RHS[1] = ( xdata * ydata * zdata ).sum();
RHS[2] = ( ydata * ydata * zdata ).sum();
double tik_delta = 1e-1 * abs(RHS).min();
std::vector<double> ATA(9); // A'A
ATA[0] = tik_delta + (xdata * xdata * xdata * xdata).sum();
ATA[1] = (xdata * xdata * xdata * ydata).sum();
ATA[2] = (xdata * xdata * ydata * ydata).sum();
ATA[3] = (xdata * ydata * xdata * xdata).sum();
ATA[4] = tik_delta + (xdata * ydata * xdata * ydata).sum();
ATA[5] = (xdata * ydata * ydata * ydata).sum();
ATA[6] = (ydata * ydata * xdata * xdata).sum();
ATA[7] = (ydata * ydata * xdata * ydata).sum();
ATA[8] = tik_delta + (ydata * ydata * ydata * ydata).sum();
int maxits = 1000;
std::valarray<double> abc = RHS; // initial guess
std::valarray<double> LHS(3);
pkmult( abc, ATA, LHS );
double res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
double tol = 1e-8;
int iter = 0;
while( iter < maxits && res > tol )
{
iter++;
abc[0] = (RHS[0] - ( abc[1]*ATA[1] + abc[2]*ATA[2] ) )/ ATA[0];
abc[1] = (RHS[1] - ( abc[0]*ATA[3] + abc[2]*ATA[5] ) )/ ATA[4];
abc[2] = (RHS[2] - ( abc[0]*ATA[6] + abc[1]*ATA[7] ) )/ ATA[8];
pkmult( abc, ATA, LHS );
res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
}
// step 5. get the derivatives from quadratic form
double phi_xx = 2*abc[0];
double phi_xy = abc[1];
double phi_yy = 2*abc[2];
kappa[k_] = phi_y * phi_y * phi_xx - 2 * phi_x * phi_y * phi_xy + phi_x * phi_x * phi_yy;
if( abs(phi_x) + abs(phi_y) > 1e-9 )
{
kappa[k_] /= pow( (phi_x*phi_x + phi_y*phi_y), 1.5 );
}
}
}
void MeshEnergy::GetNormalsTangentPlane( const std::vector<int>& C, const std::vector<double>& phi,
std::valarray<double>& ne1, std::valarray<double>& ne2,
MeshData* vtkNotUsed(meshdata))
{
vtkPoints* verts = meshdata->polydata->GetPoints();
for( ::size_t k_ = 0; k_ < C.size(); k_++ )
{
int k = C[k_];
std::vector<double> nhat(3);
nhat[0] = meshdata->nx[k]; // these are normal to surface; the nx_ are the contour normals
nhat[1] = meshdata->ny[k];
nhat[2] = meshdata->nz[k];
// step 1. create the rotation matrix that orients the current normal as [0,0,1]'.
double phiang = atan2( nhat[0], nhat[1] );
std::vector<double> rotate1(9);
rotate1[0] = cos(phiang); rotate1[1] = -sin(phiang); rotate1[2] = 0;
rotate1[3] = sin(phiang); rotate1[4] = cos(phiang); rotate1[5] = 0;
rotate1[6] = 0; rotate1[7] = 0; rotate1[8] = 1.0;
std::vector<double> nhat_a(3);
pkmult( nhat, rotate1, nhat_a );
double ytilde = nhat_a[1];
double theta = M_PI_2 - atan2(nhat[2],ytilde);
std::vector<double> rotate2(9);
rotate2[0] = 1.0; rotate2[1] = 0; rotate2[2] = 0;
rotate2[3] = 0; rotate2[4] = cos(theta); rotate2[5] = -sin(theta);
rotate2[6] = 0; rotate2[7] = sin(theta); rotate2[8] = cos(theta);
std::vector<double> nhat_b(3);
pkmult( nhat_a, rotate2, nhat_b );
// nhat_b should now be [0 0 1]'
double thispt[3];
verts->GetPoint( k, thispt );
// apply rotate2 * rotate1 to each *translated* neighbor of this k-th point
::size_t num_neigh = meshdata->adj[k].myNeighbs.size();
double vec[3];
std::vector<double> vv(3);
std::vector<double> vv_(3);
std::valarray<double> xdata(num_neigh);
std::valarray<double> ydata(num_neigh);
std::valarray<double> zdata(num_neigh);
// step 2. create temporary set of std::vectors as copies of neighboring points
// translated to origin
// step 3. apply the rotation to all these points
for ( ::size_t i = 0; i < num_neigh; i++ )
{
int idx = meshdata->adj[k].myNeighbs[i];
verts->GetPoint( idx, vec );
vv[0] = vec[0] - thispt[0];
vv[1] = vec[1] - thispt[1];
vv[2] = vec[2] - thispt[2];
pkmult( vv, rotate1, vv_ );
pkmult( vv_, rotate2, vv );
xdata[i] = vv[0];
ydata[i] = vv[1];
zdata[i] = phi[idx] - phi[k]; //vv[2];
// zero reference phi at the vertex where we are forming tangent plane
}
/*if( abs(zdata).min() < 1e-6 )
continue;*/
// step 4. find least-squares fit for H(x,y) = ax + by
std::valarray<double> RHS(2);
std::valarray<double> ATA(4);
ATA[0] = (xdata * xdata).sum();
ATA[1] = (xdata * ydata).sum();
ATA[2] = ATA[1];
ATA[3] = (ydata * ydata).sum();
RHS[0] = (xdata * zdata).sum();
RHS[1] = (ydata * zdata).sum();
int maxits = 1000;
std::valarray<double> ab = RHS; // initial guess
std::valarray<double> LHS(2);
pkmult2( ab, ATA, LHS );
double res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
double tol = 1e-8;
int iter = 0;
while( iter < maxits && res > tol )
{
iter++;
ab[0] = (RHS[0] - ( ab[1]*ATA[1] ) )/ ATA[0];
ab[1] = (RHS[1] - ( ab[0]*ATA[2] ) )/ ATA[3];
pkmult2( ab, ATA, LHS );
res = sqrt( ( (LHS - RHS)*(LHS - RHS) ).sum() );
}
ne1[k_] = ab[0] / sqrt( (ab*ab).sum() );
ne2[k_] = ab[1] / sqrt( (ab*ab).sum() );
// step 5. differentiate the plane along principal directions
}
}
void ConstructL_Unst(
const double t,
const dTensor2* vel_vec,
const mesh& Mesh,
const edge_data_Unst& EdgeData,
dTensor3& aux, // SetBndValues_Unst modifies ghost cells
dTensor3& q, // SetBndValues_Unst modifies ghost cells
dTensor3& Lstar,
dTensor1& smax)
{
const int NumElems = Mesh.get_NumElems();
const int NumPhysElems = Mesh.get_NumPhysElems();
const int NumEdges = Mesh.get_NumEdges();
const int meqn = q.getsize(2);
const int kmax = q.getsize(3);
const int maux = aux.getsize(2);
const int space_order = dogParams.get_space_order();
dTensor3 EdgeFluxIntegral(NumElems,meqn,kmax);
dTensor3 ElemFluxIntegral(NumElems,meqn,kmax);
dTensor3 Psi(NumElems,meqn,kmax);
// ---------------------------------------------------------
// Boundary Conditions
SetBndValues_Unst(Mesh,&q,&aux);
// Positivity limiter
void ApplyPosLimiter_Unst(const mesh& Mesh, const dTensor3& aux, dTensor3& q);
if( dogParams.using_moment_limiter() )
{ ApplyPosLimiter_Unst(Mesh, aux, q); }
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part I: compute flux integral on element edges
// ---------------------------------------------------------
// Loop over all interior edges and solve Riemann problems
// dTensor1 nvec(2);
// Loop over all interior edges
EdgeFluxIntegral.setall(0.);
ElemFluxIntegral.setall(0.);
// Loop over all interior edges
#pragma omp parallel for
for (int i=1; i<=NumEdges; i++)
{
// Edge coordinates
double x1 = Mesh.get_edge(i,1);
double y1 = Mesh.get_edge(i,2);
double x2 = Mesh.get_edge(i,3);
double y2 = Mesh.get_edge(i,4);
// Elements on either side of edge
int ileft = Mesh.get_eelem(i,1);
int iright = Mesh.get_eelem(i,2);
double Areal = Mesh.get_area_prim(ileft);
double Arear = Mesh.get_area_prim(iright);
// Scaled normal to edge
dTensor1 nhat(2);
nhat.set(1, (y2-y1) );
nhat.set(2, (x1-x2) );
// Variables to store flux integrals along edge
dTensor2 Fr_tmp(meqn,dogParams.get_space_order());
dTensor2 Fl_tmp(meqn,dogParams.get_space_order());
// Loop over number of quadrature points along each edge
for (int ell=1; ell<=dogParams.get_space_order(); ell++)
{
dTensor1 Ql(meqn),Qr(meqn);
dTensor1 Auxl(maux),Auxr(maux);
// Riemann data - q
for (int m=1; m<=meqn; m++)
{
Ql.set(m, 0.0 );
Qr.set(m, 0.0 );
for (int k=1; k<=kmax; k++)
{
Ql.set(m, Ql.get(m) + EdgeData.phi_left->get(i,ell,k)
*q.get(ileft, m,k) );
Qr.set(m, Qr.get(m) + EdgeData.phi_right->get(i,ell,k)
*q.get(iright,m,k) );
}
}
// Riemann data - aux
for (int m=1; m<=maux; m++)
{
Auxl.set(m, 0.0 );
Auxr.set(m, 0.0 );
for (int k=1; k<=kmax; k++)
{
Auxl.set(m, Auxl.get(m) + EdgeData.phi_left->get(i,ell,k)
*aux.get(ileft, m,k) );
Auxr.set(m, Auxr.get(m) + EdgeData.phi_right->get(i,ell,k)
*aux.get(iright,m,k) );
}
}
// Solve Riemann problem
dTensor1 xedge(2);
double s = EdgeData.xpts1d->get(ell);
xedge.set(1, x1 + 0.5*(s+1.0)*(x2-x1) );
xedge.set(2, y1 + 0.5*(s+1.0)*(y2-y1) );
dTensor1 Fl(meqn),Fr(meqn);
const double smax_edge = RiemannSolve(vel_vec, nhat, xedge, Ql, Qr, Auxl, Auxr, Fl, Fr);
smax.set(i, Max(smax_edge,smax.get(i)) );
// Construct fluxes
for (int m=1; m<=meqn; m++)
{
Fr_tmp.set(m,ell, Fr.get(m) );
Fl_tmp.set(m,ell, Fl.get(m) );
}
}
// Add edge integral to line integral around the full element
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
double Fl_sum = 0.0;
double Fr_sum = 0.0;
for (int ell=1; ell<=dogParams.get_space_order(); ell++)
{
Fl_sum = Fl_sum + 0.5*EdgeData.wgts1d->get(ell)
*EdgeData.phi_left->get(i,ell,k) *Fl_tmp.get(m,ell);
Fr_sum = Fr_sum + 0.5*EdgeData.wgts1d->get(ell)
*EdgeData.phi_right->get(i,ell,k)*Fr_tmp.get(m,ell);
}
EdgeFluxIntegral.set(ileft, m,k, EdgeFluxIntegral.get(ileft, m,k) + Fl_sum/Areal );
EdgeFluxIntegral.set(iright,m,k, EdgeFluxIntegral.get(iright,m,k) - Fr_sum/Arear );
}
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part II: compute intra-element contributions
// ---------------------------------------------------------
L2ProjectGrad_Unst(vel_vec, 1,NumPhysElems,
space_order,space_order,space_order,space_order,
Mesh,&q,&aux,&ElemFluxIntegral,&FluxFunc);
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part III: compute source term
// ---------------------------------------------------------
if ( dogParams.get_source_term()>0 )
{
// Set source term on computational grid
// Set values and apply L2-projection
L2Project_Unst(t, vel_vec, 1,NumPhysElems,
space_order,space_order,space_order,space_order,
Mesh,&q,&aux,&Psi,&SourceTermFunc);
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part IV: construct Lstar
// ---------------------------------------------------------
if (dogParams.get_source_term()==0) // Without Source Term
{
#pragma omp parallel for
for (int i=1; i<=NumPhysElems; i++)
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
double tmp = ElemFluxIntegral.get(i,m,k) - EdgeFluxIntegral.get(i,m,k);
Lstar.set(i,m,k, tmp );
}
}
else // With Source Term
{
#pragma omp parallel for
for (int i=1; i<=NumPhysElems; i++)
for (int m=1; m<=meqn; m++)
for (int k=1; k<=kmax; k++)
{
double tmp = ElemFluxIntegral.get(i,m,k)
- EdgeFluxIntegral.get(i,m,k)
+ Psi.get(i,m,k);
Lstar.set(i,m,k, tmp );
}
}
// ---------------------------------------------------------
// ---------------------------------------------------------
// Part V: add extra contributions to Lstar
// ---------------------------------------------------------
// Call LstarExtra
LstarExtra_Unst(Mesh,&q,&aux,&Lstar);
// ---------------------------------------------------------
}
