void ConSoln_Unst(const mesh& Mesh,
const dTensor3& aux,
const dTensor3& q,
double t,
string outputdir)
{
const int NumElems = q.getsize(1);
const int meqn = q.getsize(2);
const int kmax = q.getsize(3);
const int maux = aux.getsize(2);
const string fname1 = outputdir+"/conservation.dat";
ofstream write_file1,write_file2;
dTensor1 qsum(meqn);
dTensor1 res_sum(meqn);
const int NumPhysElems = Mesh.get_NumPhysElems();
if (t==0)
{
write_file1.open(fname1.c_str(), ofstream::out);
}
else
{
write_file1.open(fname1.c_str(), ofstream::app);
}
// -----------------
// CONSERVATION
// -----------------
if (dogParams.get_mcapa()<1) // without capacity function
{
for (int m=1; m<=meqn; m++)
{
qsum.set(m,0.0);
for (int i=1; i<=NumPhysElems; i++)
{
double dtmp = Mesh.get_area_prim(i);
double qtmp = q.get(i,m,1);
qsum.set(m, (qsum.get(m) + dtmp*qtmp) );
}
}
}
write_file1 << setprecision(16);
write_file1 << setw(24) << scientific << t << " ";
for (int m=1; m<=meqn; m++)
{
if (fabs(qsum.get(m)) < 1.0e-99) {qsum.set(m, 0.0);}
write_file1 << setw(24) << scientific << qsum.get(m) << " ";
}
write_file1 << endl;
write_file1.close();
}
double GetCFL_Unst(double dt, const mesh& Mesh,
const dTensor3& aux, const dTensor1& smax)
{
double cfl=-100.0;
int NumPhysElems = Mesh.get_NumPhysElems();
int NumEdges = Mesh.get_NumEdges();
for (int i=1; i<=NumPhysElems; i++)
{
double Area = Mesh.get_area_prim(i);
int edge1 = Mesh.get_tedge(i,1);
int edge2 = Mesh.get_tedge(i,2);
int edge3 = Mesh.get_tedge(i,3);
double tmp = Max(Max(smax.get(edge1),smax.get(edge2)),
smax.get(edge3));
cfl = Max(0.5*dt*tmp/Area, cfl);
}
return cfl;
}
//
// Output basic mesh information to screen
//
void ScreenOutput(const mesh& Mesh)
{
// Compute mesh quality parameters
double totalarea = Mesh.get_area_prim(1);
double maxarea = Mesh.get_area_prim(1);
double minarea = Mesh.get_area_prim(1);
for (int i=2; i<=Mesh.get_NumPhysElems(); i++)
{
double tmp = Mesh.get_area_prim(i);
totalarea = totalarea + tmp;
if (tmp < minarea)
{ minarea = tmp; }
if (tmp > maxarea)
{ maxarea = tmp; }
}
double minAngle = 180.0;
for (int i=1; i<=Mesh.get_NumPhysElems(); i++)
{
const int i1 = Mesh.get_tnode(i,1);
const int i2 = Mesh.get_tnode(i,2);
const int i3 = Mesh.get_tnode(i,3);
point v12, v23, v31;
v12.x = Mesh.get_node(i2,1) - Mesh.get_node(i1,1);
v12.y = Mesh.get_node(i2,2) - Mesh.get_node(i1,2);
v23.x = Mesh.get_node(i3,1) - Mesh.get_node(i2,1);
v23.y = Mesh.get_node(i3,2) - Mesh.get_node(i2,2);
v31.x = Mesh.get_node(i1,1) - Mesh.get_node(i3,1);
v31.y = Mesh.get_node(i1,2) - Mesh.get_node(i3,2);
double angle1 = acos((v12.x*-v31.x+v12.y*-v31.y)
/(sqrt(v12.x*v12.x+v12.y*v12.y)*sqrt(v31.x*v31.x+v31.y*v31.y)));
double angle2 = acos((v23.x*-v12.x+v23.y*-v12.y)
/(sqrt(v23.x*v23.x+v23.y*v23.y)*sqrt(v12.x*v12.x+v12.y*v12.y)));
double angle3 = acos((v31.x*-v23.x+v31.y*-v23.y)
/(sqrt(v31.x*v31.x+v31.y*v31.y)*sqrt(v23.x*v23.x+v23.y*v23.y)));
if ((angle1*180/pi) < minAngle)
{ minAngle = angle1*180/pi; }
if ((angle2*180/pi) < minAngle)
{ minAngle = angle2*180/pi; }
if ((angle3*180/pi) < minAngle)
{ minAngle = angle3*180/pi; }
}
// Output summary of results to screen
printf("\n");
printf(" SUMMARY OF RESULTS:\n");
printf(" -------------------\n");
printf(" Number of Elements: %8i\n",Mesh.get_NumElems());
printf(" Number of Physical Elements: %8i\n",Mesh.get_NumPhysElems());
printf(" Number of Ghost Elements: %8i\n",Mesh.get_NumGhostElems());
printf(" Number of Nodes: %8i\n",Mesh.get_NumNodes());
printf(" Number of Physical Nodes: %8i\n",Mesh.get_NumPhysNodes());
printf(" Number of Boundary Nodes: %8i\n",Mesh.get_NumBndNodes());
printf(" Number of Edges: %8i\n",Mesh.get_NumEdges());
printf(" Number of Boundary Edges: %8i\n",Mesh.get_NumBndEdges());
printf("\n");
printf(" Total Area Covered: %24.16e\n",totalarea);
printf(" Area Ratio: small/large: %24.16e\n",minarea/maxarea);
printf(" Angle Ratio: minAngle/60: %24.16e\n",minAngle/60.0);
printf("\n");
}
void ComputeError(const int space_order,
const mesh& Mesh,
const dTensor1& phi,
const dTensor2& E1,
const dTensor2& E2,
void (*PhiFunc)(const dTensor2& xpts,dTensor2& phi_ex),
void (*EfieldFunc)(const dTensor2& xpts,dTensor2& Efield_ex))
{
// Potential
const int NumPhysNodes = phi.getsize();//Mesh.get_NumPhysNodes();
dTensor2 xpts(NumPhysNodes,2);
dTensor2 phi_ex(NumPhysNodes,1);
double phi_err;
double phi_rel;
switch(space_order)
{
case 2:
for (int i=1; i<=NumPhysNodes; i++)
{
xpts.set(i,1, Mesh.get_node(i,1) );
xpts.set(i,2, Mesh.get_node(i,2) );
}
PhiFunc(xpts,phi_ex);
phi_err = 0.0;
phi_rel = 0.0;
for (int i=1; i<=NumPhysNodes; i++)
{
phi_rel = phi_rel + pow(phi_ex.get(i,1),2);
phi_err = phi_err + pow(phi_ex.get(i,1)-phi.get(i),2);
}
phi_err = sqrt(phi_err/phi_rel);
break;
case 3:
for (int i=1; i<=NumPhysNodes; i++)
{
xpts.set(i,1, Mesh.get_sub_node(i,1) );
xpts.set(i,2, Mesh.get_sub_node(i,2) );
}
PhiFunc(xpts,phi_ex);
phi_err = 0.0;
phi_rel = 0.0;
for (int i=1; i<=NumPhysNodes; i++)
{
phi_rel = phi_rel + pow(phi_ex.get(i,1),2);
phi_err = phi_err + pow(phi_ex.get(i,1)-phi.get(i),2);
}
phi_err = sqrt(phi_err/phi_rel);
break;
}
// Electric field components
void L2Project_Unst(const int istart,
const int iend,
const int QuadOrder,
const int BasisOrder_fout,
const mesh& Mesh,
dTensor3* fout,
void (*Func)(const dTensor2&,dTensor2&));
const int NumElems = Mesh.get_NumElems();
const int NumPhysElems = Mesh.get_NumPhysElems();
const int kmax = E1.getsize(2);
dTensor3 Efield_ex(NumElems,2,kmax);
L2Project_Unst(1,NumElems,space_order,space_order,
Mesh,&Efield_ex,EfieldFunc);
double E1_err = 0.0;
double E1_rel = 0.0;
double E2_err = 0.0;
double E2_rel = 0.0;
for (int i=1; i<=NumPhysElems; i++)
{
double Area = Mesh.get_area_prim(i);
double tmp1 = 0.0;
double tmp2 = 0.0;
double tmp1_rel = 0.0;
double tmp2_rel = 0.0;
for (int k=1; k<=kmax; k++)
{
tmp1 = tmp1 + pow((E1.get(i,k)-Efield_ex.get(i,1,k)),2);
tmp2 = tmp2 + pow((E2.get(i,k)-Efield_ex.get(i,2,k)),2);
tmp1_rel = tmp1_rel + pow((Efield_ex.get(i,1,k)),2);
tmp2_rel = tmp2_rel + pow((Efield_ex.get(i,2,k)),2);
}
E1_err = E1_err + Area*tmp1;
E2_err = E2_err + Area*tmp2;
E1_rel = E1_rel + Area*tmp1_rel;
E2_rel = E2_rel + Area*tmp2_rel;
}
E1_err = sqrt(E1_err/E1_rel);
E2_err = sqrt(E2_err/E2_rel);
// Summary
printf(" |----------------------------\n");
printf(" | Errors:\n");
printf(" |----------------------------\n");
printf(" | phi_err = %e\n",phi_err);
printf(" | E1_err = %e\n",E1_err);
printf(" | E2_err = %e\n",E2_err);
printf(" |----------------------------\n");
printf("\n");
}
// Save the time, and print the L2-norm of the electric field
//
// TODO - is this the spot where we'd like to print moments? Do we need
// moments after each time step or for each frame?
//
void PrintElectricField( const double t, const mesh& Mesh, const dTensorBC5& q,
const dTensor2& E1, const dTensor2& E2 )
{
const int mx = q.getsize(1);
const int my = q.getsize(2);
const int NumElems = q.getsize(3);
const int meqn = q.getsize(4);
const int kmax = q.getsize(5);
const int mbc = q.getmbc();
const int NumPhysElems = Mesh.get_NumPhysElems();
string fname1 = string(dogParams.get_outputdir())+"/conservation.dat";
string fname2 = string(dogParams.get_outputdir())+"/Efield.dat";
ofstream write_file1,write_file2;
if( fabs(t) < EPSILON )
{
write_file1.open(fname1.c_str(), ofstream::out);
write_file2.open(fname2.c_str(), ofstream::out);
}
else
{
write_file1.open(fname1.c_str(), ofstream::app);
write_file2.open(fname2.c_str(), ofstream::app);
}
// -----------------
// CONSERVATION
// -----------------
dTensor1 qsum(meqn);
if (dogParams.get_mcapa()<1) // without capacity function
{
for (int m=1; m<=meqn; m++)
{
qsum.set(m,0.0);
for (int i=1; i<=mx; i++)
for (int j=1; j<=my; j++)
for (int n=1; n<=NumPhysElems; n++)
{
qsum.set(m, qsum.get(m) + Mesh.get_area_prim(n)*dogParamsCart2.get_prim_vol()*q.get(i,j,n,m,1) );
}
}
}
write_file1 << setprecision(16);
write_file1 << setw(24) << scientific << t << " ";
for (int m=1; m<=meqn; m++)
{
if (fabs(qsum.get(m)) < 1.0e-99) {
qsum.set(m, 0.0);
}
write_file1 << setw(24) << scientific << qsum.get(m) << " ";
}
write_file1 << endl;
write_file1.close();
///////////////////////////////////////////////////////////////////////////
// Conserved Vlasov-Poisson Quantities //
// ||f||_1, ||f||_2, Energy, Entropy //
///////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Electric Field
const int mcons = 4;
// TODO - do we want to compute the extra moments here or later?
////dTensorBC4 ConsData2d(mx, my, mcons, kmax,mbc);
////const int space_order = dogParams.get_space_order();
////L2Project(1, mx, 1, my, space_order, space_order, space_order,
//// space_order, &q, &aux, &ConsData2d, &ConservedFunc );
// electric field, entropy and energy
dTensor1 ConsData(mcons);
ConsData.setall(0.);
// Compute the integral of all the 2d quantities:
// for (int m=1; m<=mcons; m++)
// {
// for (int i=1; i<=mx; i++)
// for (int j=1; j<=my; j++)
// {
// ConsData.set(m, ConsData.get(m) + dx*dy*ConsData2d.get(i,j,m,1) );
// }
// }
// Compute the integral of all the 1d quanties:
// \int E^2 \ dx
double Esqd = 0.0;
for(int n=1; n <= NumElems; n++ )
for(int k=1; k <= E1.getsize(2); k++ )
{
Esqd += Mesh.get_area_prim(n) * (
pow( E1.get(n,k), 2 ) + pow(E2.get(n,k), 2 )
);
}
//printf("Esqd = %f\n", Esqd );
//exit(1);
// Add in E to the total Energy:
// ConsData.set(3, ConsData.get(3) + 0.5 * E2 );
ConsData.set(3, 0. );
// print time:
write_file2 << setprecision(16);
write_file2 << setw(24) << scientific << t << " ";
// print ||E||_2 first:
write_file2 << setw(24) << scientific << sqrt( Esqd ) << " ";
// print all the other conserved quantities:
for (int m=1; m<=mcons; m++)
{
write_file2 << setw(24) << scientific << ConsData.get(m) << " ";
}
write_file2 << endl;
write_file2.close();
}
// 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); }
// ---------------------------------------------------------
}
// This routine simply glues together many of the routines that are already
// written in the Poisson solver library
//
// phi( 1:SubNumPhysNodes ) is a scalar quantity.
//
// E1 ( 1:NumElems, 1:kmax2d ) is a vector quantity.
// E2 ( 1:NumElems, 1:kmax2d ) is a vector quantity.
//
// See also: ConvertEfieldOntoDGbasis
void ComputeElectricField( const double t, const mesh& Mesh, const dTensorBC5& q,
dTensor2& E1, dTensor2& E2)
{
//
const int mx = q.getsize(1); assert_eq(mx,dogParamsCart2.get_mx());
const int my = q.getsize(2); assert_eq(my,dogParamsCart2.get_my());
const int NumElems = q.getsize(3);
const int meqn = q.getsize(4);
const int kmax = q.getsize(5);
const int space_order = dogParams.get_space_order();
// unstructured parameters:
const int kmax2d = E2.getsize(2);
const int NumBndNodes = Mesh.get_NumBndNodes();
const int NumPhysNodes = Mesh.get_NumPhysNodes();
// Quick error check
if( !Mesh.get_is_submesh() )
{
printf("ERROR: mesh needs to have subfactor set to %d\n", space_order);
printf("Go to Unstructured mesh and remesh the problem\n");
exit(-1);
}
const int SubFactor = Mesh.get_SubFactor();
assert_eq( NumElems, Mesh.get_NumElems() );
// -- Step 1: Compute rho -- //
dTensor3 rho(NumElems, 1, kmax2d );
void ComputeDensity( const mesh& Mesh, const dTensorBC5& q, dTensor3& rho );
ComputeDensity( Mesh, q, rho );
// -- Step 2: Figure out how large phi needs to be
int SubNumPhysNodes = 0;
int SubNumBndNodes = 0;
switch( dogParams.get_space_order() )
{
case 1:
SubNumPhysNodes = NumPhysNodes;
SubNumBndNodes = NumBndNodes;
break;
case 2:
SubNumPhysNodes = Mesh.get_SubNumPhysNodes();
SubNumBndNodes = Mesh.get_SubNumBndNodes();
if(SubFactor!=2)
{
printf("\n");
printf(" Error: for space_order = %i, need SubFactor = %i\n",space_order,2);
printf(" SubFactor = %i\n",SubFactor);
printf("\n");
exit(1);
}
break;
case 3:
SubNumPhysNodes = Mesh.get_SubNumPhysNodes();
SubNumBndNodes = Mesh.get_SubNumBndNodes();
if(SubFactor!=3)
{
printf("\n");
printf(" Error: for space_order = %i, need SubFactor = %i\n",space_order,3);
printf(" SubFactor = %i\n",SubFactor);
printf("\n");
exit(1);
}
break;
default:
printf("\n");
printf(" ERROR in RunDogpack_unst.cpp: space_order value not supported.\n");
printf(" space_order = %i\n",space_order);
printf("\n");
exit(1);
}
// local storage:
dTensor1 rhs(SubNumPhysNodes);
dTensor1 phi(SubNumPhysNodes);
// Get Cholesky factorization matrix R
//
// TODO - this should be saved earlier in the code rather than reading
// from file every time we with to run a Poisson solve!
//
SparseCholesky R(SubNumPhysNodes);
string outputdir = dogParams.get_outputdir();
R.init(outputdir);
R.read(outputdir);
// Create right-hand side vector
void Rhs2D_unst(const int space_order,
const mesh& Mesh, const dTensor3& rhs_dg,
dTensor1& rhs);
Rhs2D_unst(space_order, Mesh, rho, rhs);
// Call Poisson solver
void PoissonSolver2D_unst(const int space_order,
const mesh& Mesh,
const SparseCholesky& R,
const dTensor1& rhs,
dTensor1& phi,
dTensor2& E1,
dTensor2& E2);
PoissonSolver2D_unst(space_order, Mesh, R, rhs, phi, E1, E2);
// Compare errors with the exact Electric field:
//
void L2Project_Unst(
const double time,
const dTensor2* vel_vec,
const int istart,
const int iend,
const int QuadOrder,
const int BasisOrder_qin,
const int BasisOrder_auxin,
const int BasisOrder_fout,
const mesh& Mesh,
const dTensor3* qin,
const dTensor3* auxin,
dTensor3* fout,
void (*Func)(const double t, const dTensor2* vel_vec, const dTensor2&,const dTensor2&,
const dTensor2&,dTensor2&));
const int sorder = dogParams.get_space_order();
dTensor3 qtmp (NumElems, 2, kmax2d ); qtmp.setall(0.);
dTensor3 auxtmp (NumElems, 0, kmax2d );
dTensor3 ExactE (NumElems, 2, kmax2d );
L2Project_Unst( t, NULL, 1, NumElems,
sorder, sorder, sorder, sorder, Mesh,
&qtmp, &auxtmp, &ExactE,
&ExactElectricField );
// Compute errors on these two:
//
double err = 0.;
for( int n=1; n <= NumElems; n++ )
for( int k=1; k <= kmax2d; k++ )
{
err += Mesh.get_area_prim(n)*pow( ExactE.get(n,1,k) - E1.get(n,k), 2 );
err += Mesh.get_area_prim(n)*pow( ExactE.get(n,2,k) - E2.get(n,k), 2 );
}
printf("error = %2.15e\n", err );
}
void ConstructA_CG2(const mesh& Mesh, FullMatrix& A)
{
const int NumPhysElems = Mesh.get_NumPhysElems();
const int NumBndNodes = Mesh.get_SubNumBndNodes();
const int Asize = Mesh.get_SubNumPhysNodes();
assert_eq(Asize,A.get_NumRows());
assert_eq(Asize,A.get_NumCols());
dTensor1 A1(6);
dTensor1 A2(6);
dTensor1 A3(6);
dTensor1 A4(6);
dTensor1 A5(6);
dTensor1 A6(6);
A1.set(1, -oneninth );
A1.set(2, 4.0*oneninth );
A1.set(3, -oneninth );
A1.set(4, 4.0*oneninth );
A1.set(5, 4.0*oneninth );
A1.set(6, -oneninth );
A2.set(1, -onethird );
A2.set(2, 0.0 );
A2.set(3, onethird );
A2.set(4, -4.0*onethird );
A2.set(5, 4.0*onethird );
A2.set(6, 0.0 );
A3.set(1, -onethird );
A3.set(2, -4.0*onethird );
A3.set(3, 0.0 );
A3.set(4, 0.0 );
A3.set(5, 4.0*onethird );
A3.set(6, onethird );
A4.set(1, 4.0 );
A4.set(2, -4.0 );
A4.set(3, 0.0 );
A4.set(4, -4.0 );
A4.set(5, 4.0 );
A4.set(6, 0.0 );
A5.set(1, 2.0 );
A5.set(2, -4.0 );
A5.set(3, 2.0 );
A5.set(4, 0.0 );
A5.set(5, 0.0 );
A5.set(6, 0.0 );
A6.set(1, 2.0 );
A6.set(2, 0.0 );
A6.set(3, 0.0 );
A6.set(4, -4.0 );
A6.set(5, 0.0 );
A6.set(6, 2.0 );
dTensor2 spts(3,2);
spts.set(1,1, 1.0/3.0 );
spts.set(1,2, -1.0/6.0 );
spts.set(2,1, -1.0/6.0 );
spts.set(2,2, -1.0/6.0 );
spts.set(3,1, -1.0/6.0 );
spts.set(3,2, 1.0/3.0 );
dTensor1 wgts(3);
wgts.set(1, 1.0/6.0 );
wgts.set(2, 1.0/6.0 );
wgts.set(3, 1.0/6.0 );
// Loop over all elements in the mesh
for (int i=1; i<=NumPhysElems; i++)
{
// Information for element i
iTensor1 tt(6);
for (int k=1; k<=6; k++)
{ tt.set(k, Mesh.get_node_subs(i,k) ); }
// Evaluate gradients of the Lagrange polynomials on Gauss quadrature points
dTensor2 gpx(6,3);
dTensor2 gpy(6,3);
for (int m=1; m<=3; m++)
{
double xi = spts.get(m,1);
double eta = spts.get(m,2);
for (int k=1; k<=6; k++)
{
double gp_xi = A2.get(k) + 2.0*A5.get(k)*xi + A4.get(k)*eta;
double gp_eta = A3.get(k) + A4.get(k)*xi + 2.0*A6.get(k)*eta;
gpx.set(k,m, Mesh.get_jmat(i,1,1)*gp_xi
+ Mesh.get_jmat(i,1,2)*gp_eta );
gpy.set(k,m, Mesh.get_jmat(i,2,1)*gp_xi
+ Mesh.get_jmat(i,2,2)*gp_eta );
}
}
// Entries of the stiffness matrix A
double Area = Mesh.get_area_prim(i);
for (int j=1; j<=6; j++)
for (int k=1; k<=6; k++)
{
double tmp = A.get(tt.get(j),tt.get(k));
for (int m=1; m<=3; m++)
{
tmp = tmp + 2.0*Area*wgts.get(m)*(gpx.get(j,m)*gpx.get(k,m)+gpy.get(j,m)*gpy.get(k,m));
}
A.set(tt.get(j),tt.get(k), tmp );
}
}
// Replace boundary node equations by Dirichlet boundary condition enforcement
for (int i=1; i<=NumBndNodes; i++)
{
const int j=Mesh.get_sub_bnd_node(i);
for (int k=1; k<=A.get_NumCols(); k++)
{
A.set(j,k, 0.0 );
}
for (int k=1; k<=A.get_NumRows(); k++)
{
A.set(k,j, 0.0 );
}
A.set(j,j, 1.0 );
}
// Get sparse structure representation
A.Sparsify();
}
// GAUSS-LOBATTO QUADRATURE ALONG EDGE
void SetEdgeDataGL_Unst(const mesh& Mesh,
int NumQuadPoints,
int NumBasisOrder,
edge_data_Unst* EdgeData)
{
// Quick error check
if (NumQuadPoints<2 || NumQuadPoints>6 || NumBasisOrder<1 || NumBasisOrder>5)
{
printf(" \n");
printf(" Error in SetEdgeData_Unst.cpp \n");
printf(" NumQuadPoints must be 2,3,4,5, or 6.\n");
printf(" NumBasisOrder must be 1,2,3,4, or 5.\n");
printf(" NumQuadPoints = %i\n",NumQuadPoints);
printf(" NumBasisOrder = %i\n",NumBasisOrder);
printf("\n");
exit(1);
}
// ---------------------------------
// Set quadrature weights and points
// ---------------------------------
switch( NumQuadPoints )
{
case 2:
EdgeData->GL_wgts1d->set(1, 1.0 );
EdgeData->GL_wgts1d->set(2, 1.0 );
EdgeData->GL_xpts1d->set(1, 1.0 );
EdgeData->GL_xpts1d->set(2, -1.0 );
break;
case 3:
EdgeData->GL_wgts1d->set(1, onethird );
EdgeData->GL_wgts1d->set(2, 4.0*onethird );
EdgeData->GL_wgts1d->set(3, onethird );
EdgeData->GL_xpts1d->set(1, 1.0 );
EdgeData->GL_xpts1d->set(2, 0.0 );
EdgeData->GL_xpts1d->set(3, -1.0 );
break;
case 4:
EdgeData->GL_wgts1d->set(1, 0.5*onethird );
EdgeData->GL_wgts1d->set(2, 2.5*onethird );
EdgeData->GL_wgts1d->set(3, 2.5*onethird );
EdgeData->GL_wgts1d->set(4, 0.5*onethird );
EdgeData->GL_xpts1d->set(1, 1.0 );
EdgeData->GL_xpts1d->set(2, osq5 );
EdgeData->GL_xpts1d->set(3, -osq5 );
EdgeData->GL_xpts1d->set(4, -1.0 );
break;
case 5:
EdgeData->GL_wgts1d->set(1, 0.1 );
EdgeData->GL_wgts1d->set(2, 49.0/90.0 );
EdgeData->GL_wgts1d->set(3, 32.0/45.0 );
EdgeData->GL_wgts1d->set(4, 49.0/90.0 );
EdgeData->GL_wgts1d->set(5, 0.1 );
EdgeData->GL_xpts1d->set(1, 1.0 );
EdgeData->GL_xpts1d->set(2, sq3*osq7 );
EdgeData->GL_xpts1d->set(3, 0.0 );
EdgeData->GL_xpts1d->set(4, -sq3*osq7 );
EdgeData->GL_xpts1d->set(5, -1.0 );
break;
case 6:
EdgeData->GL_wgts1d->set(1, 0.2*onethird );
EdgeData->GL_wgts1d->set(2, (1.4 - 0.1*sq7)*onethird );
EdgeData->GL_wgts1d->set(3, (1.4 + 0.1*sq7)*onethird );
EdgeData->GL_wgts1d->set(4, (1.4 + 0.1*sq7)*onethird );
EdgeData->GL_wgts1d->set(5, (1.4 - 0.1*sq7)*onethird );
EdgeData->GL_wgts1d->set(6, 0.2*onethird );
EdgeData->GL_xpts1d->set(1, 1.0 );
EdgeData->GL_xpts1d->set(2, (1/21.0)*sqrt(147.0+42.0*sq7) );
EdgeData->GL_xpts1d->set(3, (1/21.0)*sqrt(147.0-42.0*sq7) );
EdgeData->GL_xpts1d->set(4, -(1/21.0)*sqrt(147.0-42.0*sq7) );
EdgeData->GL_xpts1d->set(5, -(1/21.0)*sqrt(147.0+42.0*sq7) );
EdgeData->GL_xpts1d->set(6, -1.0 );
break;
}
// ---------------------------------
// Legendre basis functions on the
// left and right of each edge
// ---------------------------------
const int NumEdges = Mesh.get_NumEdges();
const int NumBasisComps = (NumBasisOrder*(NumBasisOrder+1))/2;
dTensor1 xp1(3);
dTensor1 yp1(3);
dTensor1 xp2(3);
dTensor1 yp2(3);
dTensor1 xy1(2);
dTensor1 xy2(2);
dTensor1 mu1(NumBasisComps);
dTensor1 mu2(NumBasisComps);
for (int i=1; i<=NumEdges; i++)
{
// Get edge information
const double x1 = Mesh.get_edge(i,1);
const double y1 = Mesh.get_edge(i,2);
const double x2 = Mesh.get_edge(i,3);
const double y2 = Mesh.get_edge(i,4);
const int e1 = Mesh.get_eelem(i,1);
const int e2 = Mesh.get_eelem(i,2);
// Get element information about
// the two elements that meet at
// the current edge
const double Area1 = Mesh.get_area_prim(e1);
const double Area2 = Mesh.get_area_prim(e2);
for (int k=1; k<=3; k++)
{
xp1.set(k, Mesh.get_node(Mesh.get_tnode(e1,k),1) );
yp1.set(k, Mesh.get_node(Mesh.get_tnode(e1,k),2) );
xp2.set(k, Mesh.get_node(Mesh.get_tnode(e2,k),1) );
yp2.set(k, Mesh.get_node(Mesh.get_tnode(e2,k),2) );
}
const double xc1 = (xp1.get(1) + xp1.get(2) + xp1.get(3))/3.0;
const double yc1 = (yp1.get(1) + yp1.get(2) + yp1.get(3))/3.0;
const double xc2 = (xp2.get(1) + xp2.get(2) + xp2.get(3))/3.0;
const double yc2 = (yp2.get(1) + yp2.get(2) + yp2.get(3))/3.0;
// quadrature points on the edge
for (int m=1; m<=NumQuadPoints; m++)
{
// Take integration point s (in [-1,1])
// and map to physical domain
const double s = EdgeData->GL_xpts1d->get(m);
const double x = x1 + 0.5*(s+1.0)*(x2-x1);
const double y = y1 + 0.5*(s+1.0)*(y2-y1);
// Take physical point (x,y)
// and map into the coordinates
// of the two triangles that are
// adjacent to the current edge
xy1.set(1, ((yp1.get(3)-yp1.get(1))*(x-xc1)
+ (xp1.get(1)-xp1.get(3))*(y-yc1))/(2.0*Area1) );
xy1.set(2, ((yp1.get(1)-yp1.get(2))*(x-xc1)
+ (xp1.get(2)-xp1.get(1))*(y-yc1))/(2.0*Area1) );
xy2.set(1, ((yp2.get(3)-yp2.get(1))*(x-xc2)
+ (xp2.get(1)-xp2.get(3))*(y-yc2))/(2.0*Area2) );
xy2.set(2, ((yp2.get(1)-yp2.get(2))*(x-xc2)
+ (xp2.get(2)-xp2.get(1))*(y-yc2))/(2.0*Area2) );
// Evaluate monomials at locations xy1
double xi = xy1.get(1);
double xi2 = xi*xi;
double xi3 = xi*xi2;
double xi4 = xi*xi3;
double eta = xy1.get(2);
double eta2 = eta*eta;
double eta3 = eta*eta2;
double eta4 = eta*eta3;
switch( NumBasisOrder )
{
case 5: // fifth order
mu1.set(15, eta4 );
mu1.set(14, xi4 );
mu1.set(13, xi2*eta2 );
mu1.set(12, eta3*xi );
mu1.set(11, xi3*eta );
case 4: // fourth order
mu1.set(10, eta3 );
mu1.set(9, xi3 );
mu1.set(8, xi*eta2 );
mu1.set(7, eta*xi2 );
case 3: // third order
mu1.set(6, eta2 );
mu1.set(5, xi2 );
mu1.set(4, xi*eta );
case 2: // second order
mu1.set(3, eta );
mu1.set(2, xi );
case 1: // first order
mu1.set(1, 1.0 );
break;
}
// Evaluate monomials at locations xy2
xi = xy2.get(1);
xi2 = xi*xi;
xi3 = xi*xi2;
xi4 = xi*xi3;
eta = xy2.get(2);
eta2 = eta*eta;
eta3 = eta*eta2;
eta4 = eta*eta3;
switch( NumBasisOrder )
{
case 5: // fifth order
mu2.set(15, eta4 );
mu2.set(14, xi4 );
mu2.set(13, xi2*eta2 );
mu2.set(12, eta3*xi );
mu2.set(11, xi3*eta );
case 4: // fourth order
mu2.set(10, eta3 );
mu2.set(9, xi3 );
mu2.set(8, xi*eta2 );
mu2.set(7, eta*xi2 );
case 3: // third order
mu2.set(6, eta2 );
mu2.set(5, xi2 );
mu2.set(4, xi*eta );
case 2: // second order
mu2.set(3, eta );
mu2.set(2, xi );
case 1: // first order
mu2.set(1, 1.0 );
break;
}
// Finally, convert monomials to Legendre Polys
// on the two adjacent triangle
for (int k=1; k<=NumBasisComps; k++)
{
double tmp1 = 0.0;
double tmp2 = 0.0;
for (int j=1; j<=k; j++)
{
tmp1 = tmp1 + Mmat[k-1][j-1]*mu1.get(j);
tmp2 = tmp2 + Mmat[k-1][j-1]*mu2.get(j);
}
EdgeData->GL_phi_left->set(i,m,k, tmp1 );
EdgeData->GL_phi_right->set(i,m,k, tmp2 );
}
}
}
}
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);
// ---------------------------------------------------------
}