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