// Simple wrapper function. We have no source term in this problem, so no need
// to use void* data
void BeforeStep(double dt,
dTensorBC4& aux,
dTensorBC4& q,
DogSolverCart2& solver,
void* data)
{
BeforeStep(dt,aux,q,solver);
}
void MaterialPointSet::Update(double deltaTime)
{
BeforeStep(deltaTime);
for (unsigned int i = 0; i < m_count; ++i)
{
if (m_bounds[i] == false)
m_points[i].PrepareMove(deltaTime, Force(i));
}
AfterStep(deltaTime);
for (unsigned int i = 0; i < m_count; ++i)
{
if (m_bounds[i] == false)
m_points[i].UpdateMove();
}
}
// Function that is called after each time stage
void AfterStep(double dt, dTensorBC4& aux, dTensorBC4& q, DogSolverCart2& solver, void* data)
{
const int mx = q.getsize(1);
const int my = q.getsize(2);
const int meqn = q.getsize(3);
const int kmax = q.getsize(4);
const int mbc = q.getmbc();
const int maux = aux.getsize(3);
//return;
// Compare with exact electric and print error
dTensorBC4 Evals2d(mx,my,1,kmax,mbc);
const int istart = 1;
const int iend = mx;
const int jstart = 1;
const int jend = 1;
const int QuadOrder = 5;
L2Project_extra(istart,iend,jstart,jend,QuadOrder,
QuadOrder,QuadOrder,QuadOrder,
&q,&aux,&Evals2d, &ElectricFieldWrap, data);
// do a poisson solve on q
dTensorBC4 aux_extra(mx,my,maux,kmax,mbc);
BeforeStep(dt, aux_extra, q, solver);
double tmp = 0;
for( int i=1; i <= mx; i++)
for( int k=1; k <= kmax; k++)
{
tmp += fabs( Evals2d.get(i,1,1,k) - aux_extra.get(i,1,2,k) );
}
printf(" error in electric field = %2.8e\n", tmp);
}
// Lax-Wendroff time stepping
//
// TODO - I guess the idea is to try and incorporate this into DogSolve? I
// don't see how this can be done with this method for all dimensions ... (-DS)
void DogSolverCart2::DogSolveLxW(double tstart, double tend)
{
// Data that needs to be updated. qold -> qnew at time t=tend.
dTensorBC4& qnew = fetch_state().fetch_q();
dTensorBC4& aux = fetch_state().fetch_aux();
dTensorBC4& qold = fetch_state_old().fetch_q();
dTensorBC4& auxold = fetch_state_old().fetch_aux();
dTensorBC3& smax = fetch_smax();
// access constant data
const int time_order = dogParams.get_time_order();
const int nv = dogParams.get_nv();
const double* cflv = dogParams.get_cflv();
// TODO: can use dogParamsCart2 to get these variables:
const int mx = qnew.getsize(1);
const int my = qnew.getsize(2);
const int meqn = qnew.getsize(3);
const int kmax = qnew.getsize(4);
const int mbc = qnew.getmbc();
const int maux = aux.getsize(3);
// ------------------------------------------------------------
// Function definitions
void CopyQ(const dTensorBC4& qin,dTensorBC4& qout);
// ------------------------------------------------------------
// define local variables
int n_step = 0;
double t = tstart;
double dt = get_dt();
const double CFL_max = cflv[1];
const double CFL_target = cflv[2];
// Example of using extra information and intermediate stages:
dTensorBC4 qstar(mx, my, meqn, kmax, mbc);
dTensorBC4 auxstar(mx, my, maux, kmax, mbc);
// This memory should have already been allocated:
// (otherwise, can allocate it here, as in above):
dTensorBC4& L = fetch_L();
// Set initialize qstar and auxstar values
CopyQ(qold, qstar);
CopyQ(aux, auxstar);
// User-defined time stepping
while (t<tend)
{
// initialize time step
int m_accept = 0;
n_step = n_step + 1;
// check if max number of time steps exceeded
if (n_step>nv)
{
eprintf(" Error in DogSolveUser.cpp: "
" Exceeded allowed # of time steps \n"
" n_step = %d\n"
" nv = %d\n\n",
n_step,nv);
}
// copy qnew into qold
CopyQ(qnew, qold);
CopyQ(aux, auxold);
// keep trying until we get a dt that does not violate CFL condition
while (m_accept==0)
{
// set current time
double told = t;
if (told+dt > tend)
{ dt = tend - told; }
t = told + dt;
fetch_state().set_time(told);
dogParams.set_time(told); // TODO
set_dt(dt);
// Set initial maximum wave speed to zero
//
// TODO : CAN CALL reset smax or something ...
for (int j=1-mbc; j<=(my+mbc); j++)
{
for (int i=1-mbc; i<=(mx+mbc); i++)
{
smax.set(i, j, 1, 0.0e0 );
smax.set(i, j, 2, 0.0e0 );
}
}
BeforeStep(dt,aux,qnew,*this);
void SetBndValues(dTensorBC4&,dTensorBC4&);
SetBndValues(qnew,aux);
// Construct RHS for LxW formulation:
void LaxWendroff(double dt,
double alpha1, double beta1,
dTensorBC4& aux, dTensorBC4& q,
dTensorBC4& Lstar, dTensorBC3& smax);
LaxWendroff(dt, 1.0, 0.5, aux, qnew, L, smax);
// Take a single "Euler" time step:
void StepLxW( double dt, const dTensorBC4& qold,
const dTensorBC4& L, dTensorBC4& qnew );
StepLxW(dt, qnew, L, qnew);
if(dogParams.using_moment_limiter())
{ ::ApplyLimiter(aux,qnew,&ProjectRightEig,&ProjectLeftEig); }
AfterStep(dt, aux, qnew, *this);
// ----------------------------------------------------------------
// compute cfl number
double cfl = GetCFL(dt);
// output time step information
if (dogParams.get_verbosity()>0)
{
printf("DogSolve2D ... Step %5d"
" CFL =%6.3f"
" dt =%11.3e"
" t =%11.3e\n",
n_step,cfl,dt,t);
}
// choose new time step
if (cfl>0.0)
{
dt = Min(dogParams.get_max_dt(),dt*CFL_target/cfl);
}
else
{
dt = dogParams.get_max_dt();
}
// see whether to accept or reject this step
if (cfl<=CFL_max)
// accept
{
m_accept = 1;
// do any extra work
::AfterFullTimeStep(fetch_solver());
}
else
//reject
{
t = told;
if (dogParams.get_verbosity()>0)
{
printf("DogSolve2D rejecting step..."
"CFL number too large\n");
}
// copy qold into qnew
CopyQ(qold, qnew);
CopyQ(auxold, aux);
}
}
// compute conservation and print to file
ConSoln(aux,qnew,t);
}
// set initial time step for next call to DogSolveUser
set_dt(dt);
}
// semi-lagrangian solver
void DogSolverCart2::DogSolveUser(double tstart, double tend)
{
// this accomodates the maximum number of stages allowed for the
// split method ... and is a work in progress ...
const int MAX_STAGES = 13;
const edge_data& EdgeData = Legendre2d::instance().get_edgeData();
dTensorBC3& smax = fetch_smax();
DogStateCart2* dogStateCart2 = &fetch_state();
dTensorBC4& qnew = fetch_state().fetch_q();
dTensorBC4& qold = fetch_state_old().fetch_q();
dTensorBC4& aux = fetch_state().fetch_aux();
const int nv = dogParams.get_nv();
const double* cflv = dogParams.get_cflv();
// --------------------------------------------------------------
// define local variables
int m_accept;
const int mx = qnew.getsize(1);
const int my = qnew.getsize(2);
const int maux = aux.getsize(3);
const int meqn = qnew.getsize(3);
const int kmax = qnew.getsize(4);
const int mbc = qnew.getmbc();
const int ndims = 2;
int n_step = 0;
double t = tstart;
double tn = t;
double told = 0.0;
double dt = get_dt();
const double CFL_max = cflv[1];
const double CFL_target = cflv[2];
double cfl = 0.0;
double dtmin = dt;
double dtmax = dt;
dTensorBC4 qstar(mx,my,meqn,kmax,mbc); //temporary place holder
dTensorBC4 aux_old(mx,my,maux,kmax,mbc);
//////////////////////////////////////////////////////////////////////////
// Setup for manipulating velocities. Store 2 arrays, 1 for each velocity
//////////////////////////////////////////////////////////////////////////
// array for storing advection speeds in each cell
const int mpoints = int((1+4*kmax-int(sqrt(1+8*kmax)))/2);
const int mpoints1d = int(sqrt(mpoints));
const int morder = mpoints1d;
dTensorBC2 u1(my, mpoints1d, mbc, ndims-1); // speed, u(y) (ndims == 1 )
dTensorBC2 u2(mx, mpoints1d, mbc, ndims-1); // speed, v(x) (ndims == 1 )
////////Set up any extra state variables associated with this problem /////
SL_state sl_state;
sl_state.split_time = new dTensor2(MAX_STAGES, 2);
sl_state.aux1d = new dTensorBC4( Max(mx,my), 2, 4, mpoints1d, mbc, 1);
sl_state.node1d = new dTensor2(mx+1,1);
for( int i=1; i <=(mx+1); i++)
{ sl_state.node1d->set(i, 1, dogParamsCart2.get_xl(i) ); }
sl_state.qold = &qold;
sl_state.qnew = &qnew;
const double dx = dogParamsCart2.get_dx();
const double dy = dogParamsCart2.get_dy();
// sample grid points (gauss points)
dTensor2* spts = new dTensor2(mpoints, 2);
//legendre polys evaluated at spts
dTensor2 phi(mpoints, kmax);
dTensor1 x1d(mpoints1d);
dTensor1 wgt(mpoints1d);
void setGaussPoints1d(dTensor1& w1d, dTensor1& x1d);
setGaussPoints1d(wgt, x1d);
// Tensor product Gaussian Quadrature
// See note at top of code in how mpoints are arranged here...
int k=0;
for (int m1=1; m1<=(mpoints1d); m1++)
for (int m2=1; m2<=(mpoints1d); m2++)
{
k = k+1;
//save gauss quad grid point location on interval [-1,1]^2
spts->set(k,2, x1d.get(m1) );
spts->set(k,1, x1d.get(m2) );
}
//evaluate the legendre polynomials at sample points
for(int m=1; m <= mpoints; m++)
{
double xi, xi2,xi3,xi4, eta, eta2,eta3,eta4;
//find xi and eta (point to be evaluated)
xi = spts->get(m,1);
eta = spts->get(m,2);
xi2 = xi*xi;
xi3 = xi*xi2;
xi4 = xi*xi3;
eta2 = eta*eta;
eta3 = eta*eta2;
eta4 = eta*eta3;
// Legendre basis functions evaluated at (xi,eta) in the
// interval [-1,1]x[-1,1].
switch( mpoints1d )
{
case 5: // fifth order
phi.set( m,15, 105.0/8.0*eta4 - 45.0/4.0*eta2 + 9.0/8.0 );
phi.set( m,14, 105.0/8.0*xi4 - 45.0/4.0*xi2 + 9.0/8.0 );
phi.set( m,13, 5.0/4.0*(3.0*xi2 - 1.0)*(3.0*eta2 - 1.0) );
phi.set( m,12, sq3*sq7*(2.5*eta3 - 1.5*eta)*xi );
phi.set( m,11, sq3*sq7*(2.5*xi3 - 1.5*xi)*eta );
case 4: // fourth order
phi.set( m,10, sq7*(2.5*eta3 - 1.5*eta) );
phi.set( m,9, sq7*(2.5*xi3 - 1.5*xi) );
phi.set( m,8, sq3*sq5*xi*(1.5*eta2 - 0.5) );
phi.set( m,7, sq3*sq5*eta*(1.5*xi2 - 0.5) );
case 3: // third order
phi.set( m,6, sq5*(1.5*eta2 - 0.5) );
phi.set( m,5, sq5*(1.5*xi2 - 0.5) );
phi.set( m,4, 3.0*xi*eta );
case 2: // second order
phi.set( m,3, sq3*eta );
phi.set( m,2, sq3*xi );
case 1: // first order
phi.set( m,1, 1.0 );
}
}//end of evaluating legendre polys at sample grid points indexed by spts
delete spts;
///////////////////////////////////////////////////////////////////////////
double time1, time2; // running time values
time1 = GetTime(); //running time for this program (can remove this..)
// fourth order splitting coefficients
dTensor1* dt_stages;
if( dogParams.get_time_order() >= 2 )
{
dt_stages = new dTensor1(MAX_STAGES);
sl_state.dt_stages = dt_stages;
}
///////////////////////////////////////////////////////////////////////////
// Main Time Stepping Loop
///////////////////////////////////////////////////////////////////////////
while (t<tend)
{
// initialize time step
m_accept = 0;
n_step = n_step + 1;
// check if max number of time steps exceeded
if (n_step>nv)
{
cout << " Error in DogSolveAdvec.cpp: "<<
" Exceeded allowed # of time steps " << endl;
cout << " n_step = " << n_step << endl;
cout << " nv = " << nv << endl;
cout << endl;
exit(1);
}
// copy qnew and aux in case we reject the step
CopyQ(qnew,qold);
CopyQ(qnew,qstar);
CopyQ(aux,aux_old);
// keep trying until we get a dt that does not violate CFL condition
while (m_accept==0)
{
// set current time
told = t;
tn = t;
if (told+dt > tend) { dt = tend - told; }
t = told + dt;
// Set initial maximum wave speed to zero (this will be saved in
// SetAdvecSpeed)
for (int i=(1-mbc); i<=(mx+mbc); i++)
for (int j=(1-mbc); j<=(my+mbc); j++)
{
smax.set(i,j,1, 0.0e0 );
smax.set(i,j,2, 0.0e0 );
}
sl_state.dt = dt;
sl_state.t = sl_state.tn = tn;
void InitSLState( const dTensorBC4& q, const dTensorBC4& aux,
SL_state& sl_state );
InitSLState( qnew, aux, sl_state );
CopyQ(qold, qstar);
/////////////////////////////////////
// Perform a full time step
/////////////////////////////////////
switch ( dogParams.get_time_order() )
{
case 0: // used for testing - dont' take any time steps!
BeforeStep (dt, aux, qnew, *this);
AfterStep (dt, aux, qnew, *this);
perror( " case 0: Not taking a time step! " );
break;
case 1: // 1st order in time, no corrections
sl_state.t = tn;
BeforeStep(dt, aux, qstar, *this);
SetAdvecSpeed(phi, qstar, aux, smax, 1, u1, u2, sl_state);
SetAdvecSpeed(phi, qstar, aux, smax, 2, u1, u2, sl_state);
StepAdvec(dt, qold, qstar, aux, u1, u2, 1, sl_state);
StepAdvec(dt, qstar, qnew, aux, u1, u2, 2, sl_state);
break;
case 2: // 2nd order in time (strang split method)
SetSplitTime(dt, 2, tn, sl_state, dt_stages );
sl_state.stage_num = 1;
sl_state.t = tn;
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(0.5*dt, qstar, qnew, aux, u1, u2, 1, sl_state );
// Poisson solve called in BeforeStep for VP system
// BeforeStep(dt, aux, qstar );
sl_state.stage_num = 2;
BeforeStep(dt, aux, qnew, *this);
sl_state.t = tn;
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(dt, qnew, qstar, aux, u1, u2, 2, sl_state );
sl_state.stage_num = 3;
sl_state.t = tn + 0.5*dt;
StepAdvec(0.5*dt, qstar, qnew, aux, u1, u2, 1, sl_state);
break;
case 4: // 4th order method (Yoshida Splitting)
// initial setup ... Save all appropriate times into SL_state
SetSplitTime(dt, 4, tn, sl_state, dt_stages );
///////////////////////////////////////////////////////////
///// There are 7 stages for Yoshida Splitting /////
///////////////////////////////////////////////////////////
///////// stage 1: A //////////////////////////////////////
sl_state.stage_num = 1;
sl_state.t = sl_state.split_time->get(1,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(1), qstar, qnew, aux, u1, u2, 1, sl_state );
///////// stage 2: B //////////////////////////////////////
sl_state.stage_num = 2;
sl_state.t = sl_state.split_time->get(2,2);
SetAdvecSpeed( phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(2), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 3: A //////////////////////////////////////
sl_state.stage_num = 3;
sl_state.t = sl_state.split_time->get(3,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(3), qstar , qnew, aux, u1, u2, 1, sl_state);
///////// stage 4: B //////////////////////////////////////
sl_state.stage_num = 4;
sl_state.t = sl_state.split_time->get(4,2);
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(4), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 5: A //////////////////////////////////////
sl_state.stage_num = 5;
sl_state.t = sl_state.split_time->get(5,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(5), qstar, qnew, aux, u1, u2, 1, sl_state);
///////// stage 6: B //////////////////////////////////////
sl_state.stage_num = 6;
sl_state.t = sl_state.split_time->get(6,2);
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(6), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 7: A //////////////////////////////////////
sl_state.stage_num = 7;
sl_state.t = sl_state.split_time->get(7,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(7), qstar , qnew, aux, u1, u2, 1, sl_state);
//////////////// --- Experimental New Time Stepping --- ///////////////////
// ///////// stage 1: A //////////////////////////////////////
// sl_state.stage_num = 1;
// sl_state.t = sl_state.split_time->get(1,1);
// SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(1), qstar, qnew, aux, u1, u2, 1, sl_state );
// ///////// stage 2: B //////////////////////////////////////
// sl_state.stage_num = 2;
// sl_state.t = sl_state.split_time->get(2,2);
// SetAdvecSpeed( phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(2), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 3: A //////////////////////////////////////
// sl_state.stage_num = 3;
// sl_state.t = sl_state.split_time->get(3,1);
// StepAdvec(sl_state.dt_stages->get(3), qstar , qnew, aux, u1, u2, 1, sl_state);
// ///////// stage 4: B //////////////////////////////////////
// sl_state.stage_num = 4;
// sl_state.t = sl_state.split_time->get(4,2);
// SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(4), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 5: A //////////////////////////////////////
// sl_state.stage_num = 5;
// sl_state.t = sl_state.split_time->get(5,1);
// StepAdvec(sl_state.dt_stages->get(5), qstar, qnew, aux, u1, u2, 1, sl_state);
// ///////// stage 6: B //////////////////////////////////////
// sl_state.stage_num = 6;
// sl_state.t = sl_state.split_time->get(6,2);
// SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(6), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 7: A //////////////////////////////////////
// sl_state.stage_num = 7;
// sl_state.t = sl_state.split_time->get(7,1);
// StepAdvec(sl_state.dt_stages->get(7), qstar , qnew, aux, u1, u2, 1, sl_state);
// ///////// stage 8: B //////////////////////////////////////
// sl_state.stage_num = 8;
// sl_state.t = sl_state.split_time->get(8,2);
// SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(8), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 9: A //////////////////////////////////////
// sl_state.stage_num = 9;
// sl_state.t = sl_state.split_time->get(9,1);
// StepAdvec(sl_state.dt_stages->get(9), qstar , qnew, aux, u1, u2, 1, sl_state);
// ///////// stage 10: B //////////////////////////////////////
// sl_state.stage_num = 10;
// sl_state.t = sl_state.split_time->get(10,2);
// SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(10), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 11: A //////////////////////////////////////
// sl_state.stage_num = 11;
// sl_state.t = sl_state.split_time->get(11,1);
// StepAdvec(sl_state.dt_stages->get(11), qstar , qnew, aux, u1, u2, 1, sl_state);
// ///////// stage 12: B //////////////////////////////////////
// sl_state.stage_num = 12;
// sl_state.t = sl_state.split_time->get(12,2);
// SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
// StepAdvec(sl_state.dt_stages->get(12), qnew, qstar, aux, u1, u2, 2, sl_state);
// ///////// stage 13: A //////////////////////////////////////
// sl_state.stage_num = 13;
// sl_state.t = sl_state.split_time->get(13,1);
// StepAdvec(sl_state.dt_stages->get(13), qstar , qnew, aux, u1, u2, 1, sl_state);
//////////////// --- Experimental New Time Stepping --- ///////////////////
break;
case 6: // 6th order method (SRKN Splitting)
// Added by Pierson Guthrey 5/22/2015
// initial setup ... Save all appropriate times into SL_state
SetSplitTime(dt, 6, tn, sl_state, dt_stages );
///////// stage 1: A //////////////////////////////////////
sl_state.stage_num = 1;
sl_state.t = sl_state.split_time->get(1,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(1), qstar, qnew, aux, u1, u2, 1, sl_state );
///////// stage 2: B //////////////////////////////////////
sl_state.stage_num = 2;
sl_state.t = sl_state.split_time->get(2,2);
SetAdvecSpeed( phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(2), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 3: A //////////////////////////////////////
sl_state.stage_num = 3;
sl_state.t = sl_state.split_time->get(3,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(3), qstar , qnew, aux, u1, u2, 1, sl_state);
///////// stage 4: B //////////////////////////////////////
sl_state.stage_num = 4;
sl_state.t = sl_state.split_time->get(4,2);
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(4), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 5: A //////////////////////////////////////
sl_state.stage_num = 5;
sl_state.t = sl_state.split_time->get(5,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(5), qstar, qnew, aux, u1, u2, 1, sl_state );
///////// stage 6: B //////////////////////////////////////
sl_state.stage_num = 6;
sl_state.t = sl_state.split_time->get(6,2);
SetAdvecSpeed( phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(6), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 7: A //////////////////////////////////////
sl_state.stage_num = 7;
sl_state.t = sl_state.split_time->get(7,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(7), qstar , qnew, aux, u1, u2, 1, sl_state);
///////// stage 8: B //////////////////////////////////////
sl_state.stage_num = 8;
sl_state.t = sl_state.split_time->get(8,2);
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(8), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 9: A //////////////////////////////////////
sl_state.stage_num = 9;
sl_state.t = sl_state.split_time->get(9,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(9), qstar, qnew, aux, u1, u2, 1, sl_state );
///////// stage 10: B //////////////////////////////////////
sl_state.stage_num = 10;
sl_state.t = sl_state.split_time->get(10,2);
SetAdvecSpeed( phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(10), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 11: A //////////////////////////////////////
sl_state.stage_num = 11;
sl_state.t = sl_state.split_time->get(11,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(11), qstar , qnew, aux, u1, u2, 1, sl_state);
///////// stage 12: B //////////////////////////////////////
sl_state.stage_num = 12;
sl_state.t = sl_state.split_time->get(12,2);
SetAdvecSpeed(phi, qnew, aux, smax, 2, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(12), qnew, qstar, aux, u1, u2, 2, sl_state);
///////// stage 13: A //////////////////////////////////////
sl_state.stage_num = 13;
sl_state.t = sl_state.split_time->get(13,1);
SetAdvecSpeed( phi, qstar, aux, smax, 1, u1, u2, sl_state);
StepAdvec(sl_state.dt_stages->get(13), qstar , qnew, aux, u1, u2, 1, sl_state);
default:
// still here? too bad! Pick a valid time stepping
// method
fprintf(stderr,
"Bad time stepping method chosen in DogSolveAdvec\n");
fprintf(stderr,
"dogParams.get_time_order() = %d\n",
dogParams.get_time_order());
exit(1);
}// end of taking a full time step
// compute cfl number
cfl = GetCFL(dt);
// output time step information
if (dogParams.get_verbosity()>0)
{
cout << setprecision(3);
cout << "DogSolve2D ... Step" << setw(5) << n_step;
cout << " CFL =" << setw(6) << fixed << cfl;
cout << " dt =" << setw(11) << scientific << dt;
cout << " t =" << setw(11) << scientific << t << endl;
}
if (cfl>0.0)
{ dt = Min(dogParams.get_max_dt(),dt*CFL_target/cfl); }
else
{ dt = dogParams.get_max_dt(); }
// see whether to accept or reject this step
if (cfl<=CFL_max)
{ // accept
m_accept = 1;
dogStateCart2->set_time(t);
dogParams.set_time(t); // time hack
}
else
{ //reject
t = told;
if (dogParams.get_verbosity()>0)
{
cout<<"DogSolve2D rejecting step...";
cout<<"CFL number too large";
cout<<endl;
// find index of larger value...
int imax = 1; int jmax = 1; int dmax = 1;
for( int i = 1; i <= smax.getsize(1); i++ )
for( int j = 1; j <= smax.getsize(2); j++ )
for( int d = 1; d <= ndims; d++ )
{
if( smax.get(i,j,d) > smax.get(imax,jmax,dmax) )
{ imax = i; jmax = j; dmax = d;}
}
printf(" imax = %d, jmax = %d, dmax = %d\n", imax, jmax, dmax );
printf(" smax(imax,jmax,dmax) = %3.2e\n", smax.get(imax, jmax, dmax ) );
}
// copy qold into qnew
CopyQ(qold,qnew);
CopyQ(aux_old,aux);
}
}
void AfterFullSLTimeStep( dTensorBC4& aux, dTensorBC4& qnew, double t );
AfterFullSLTimeStep(aux, qnew, t );
// apply the limiter - This way global integrals stay positive
void ApplyPosLimiter(const dTensorBC4& aux, dTensorBC4& q);
if(dogParams.using_moment_limiter())
{ ApplyPosLimiter(aux, qnew); }
// compute conservation and print to file
ConSoln(aux,qnew,t);
}
void AfterSLFrame(double dt, dTensorBC4& aux, dTensorBC4& q, DogSolverCart2&
solver, SL_state sl_state );
AfterSLFrame(dt, aux, qnew, *this, sl_state );
// set initial time step for next call to DogSolveAdvec
set_dt(dt);
// Clock the running time for this call to DogSolveAdvec
time2 = GetTime();
if(dogParams.get_verbosity()>0)
{
cout << " DogSolveAdvec Running Time = "
<< setw(3) << time2 - time1 << " seconds" << endl << endl;
}
if( dogParams.get_time_order() >= 2 )
{
delete dt_stages;
}
delete sl_state.split_time;
delete sl_state.aux1d;
delete sl_state.node1d;
}
