67 UnsteadySystem::UnsteadySystem(
85 m_session->MatchSolverInfo(
"DIFFUSIONADVANCEMENT",
"Explicit",
87 m_session->MatchSolverInfo(
"ADVECTIONADVANCEMENT",
"Explicit",
89 m_session->MatchSolverInfo(
"REACTIONADVANCEMENT",
"Explicit",
95 if (
m_session->DefinesSolverInfo(
"TIMEINTEGRATIONMETHOD"))
99 "TIMEINTEGRATIONMETHOD"));
107 boost::lexical_cast<std::string>(
m_time);
114 LibUtilities::FilterMap::const_iterator x;
116 for (x = f.begin(); x != f.end(); ++x)
144 TimeStability = 2.784;
166 "No CFL control implementation for this time"
167 "integration scheme");
170 return TimeStability;
183 int nfields =
m_fields.num_elements();
187 for (i = 0; i < nfields; ++i)
191 nvariables = nfields;
201 for(i = 0; i < nfields; ++i)
215 for(i = 0; i < nvariables; ++i)
237 "Final condition not unique: "
238 "fintime > 0.0 and Nsteps > 0");
242 "Timestep not unique: timestep > 0.0 & CFL > 0.0");
249 "Only one of IO_CheckTime and IO_CheckSteps "
253 bool doCheckTime =
false;
300 if (
m_session->GetComm()->GetRank() == 0 &&
303 cout <<
"Steps: " << setw(8) << left << step+1 <<
" "
304 <<
"Time: " << setw(12) << left <<
m_time;
308 cout <<
" Time-step: " << setw(12)
313 ss << cpuTime <<
"s";
314 cout <<
" CPU Time: " << setw(8) << left
320 for (i = 0; i < nvariables; ++i)
342 for (i = 0; i < nvariables; ++i)
350 m_session->GetComm()->AllReduce(nanFound,
353 "NaN found during time integration.");
368 vector<bool> transformed(nfields,
false);
369 for(i = 0; i < nfields; i++)
377 transformed[i] =
true;
382 for(i = 0; i < nfields; i++)
408 if (
m_session->GetComm()->GetRank() == 0)
416 if (
m_session->GetSolverInfo(
"Driver") !=
"SteadyState")
418 cout <<
"Time-integration : " << intTime <<
"s" << endl;
425 for(i = 0; i < nfields; i++)
438 for(i = 0; i < nvariables; ++i)
478 if(
m_session->DefinesSolverInfo(
"AdvectionType"))
481 m_session->GetSolverInfo(
"AdvectionType"));
488 ==
"SteadyAdvectionDiffusionReaction")
517 outfile.open(
"solution1D.txt");
520 outfile << scientific << setw (17) << setprecision(16) << x[i]
521 <<
" " << solution1D[0][i] << endl;
523 outfile << endl << endl;
532 "This function is not implemented for this equation.");
541 "This function is not implemented for this equation.");
550 int nvariables =
m_fields.num_elements();
551 int nqvar = uflux.num_elements();
562 for (j = 0; j < nqvar; ++j)
564 for (i = 0; i < nvariables ; ++i)
567 m_fields[i]->GetFwdBwdTracePhys(ufield[i], Fwd, Bwd);
589 if(
m_fields[0]->GetBndCondExpansions().num_elements())
620 int nvariables =
m_fields.num_elements();
621 int nqvar = qfield.num_elements();
636 for (
int i = 0; i < nvariables; ++i)
639 for (
int j = 0; j < nqvar; ++j)
642 m_fields[i]->GetFwdBwdTracePhys(qfield[j][i],qFwd,qBwd);
666 m_fields[i]->GetFwdBwdTracePhys(ufield[i], Fwd, Bwd);
673 -1.0 * C11, uterm, 1,
683 if (
m_fields[0]->GetBndCondExpansions().num_elements())
704 if (
m_session->DefinesFunction(
"InitialConditions"))
706 for (
int i = 0; i <
m_fields.num_elements(); ++i)
711 "InitialConditions",
m_session->GetVariable(i));
717 "InitialConditions",
m_session->GetVariable(i));
719 fs::path pfilename(filename);
722 if(fs::is_directory(pfilename))
724 fs::path metafile(
"Info.xml");
725 fs::path fullpath = pfilename / metafile;
766 int i, e, npoints, id1, id2;
769 int nbnd =
m_fields[var]->GetBndCondExpansions().num_elements();
776 m_fields[var]->ExtractTracePhys(physfield, uplus);
777 for (i = 0; i < nbnd; ++i)
781 GetBndCondExpansions()[i]->GetExpSize();
785 m_session->GetFunction(
"InitialConditions", 0);
788 GetBndCondExpansions()[i]->GetNpoints();
795 m_fields[var]->GetBndCondExpansions()[i]->GetCoords(x0,x1,x2);
796 ifunc->Evaluate(x0,x1,x2,time,BDphysics);
799 for (e = 0; e < numBDEdge ; ++e)
803 GetBndCondExpansions()[i]->GetExp(e)->GetNumPoints(0);
806 GetBndCondExpansions()[i]->GetPhys_Offset(e);
810 GetBndCondTraceToGlobalTraceMap(cnt++));
813 if (
m_fields[var]->GetBndConditions()[i]->
818 &penaltyflux[id2], 1);
821 else if ((
m_fields[var]->GetBndConditions()[i])->
826 &penaltyflux[id2], 1);
845 int i, e, npoints, id1, id2;
846 int nbnd =
m_fields[var]->GetBndCondExpansions().num_elements();
853 m_fields[var]->ExtractTracePhys(physfield,qtemp);
855 for (i = 0; i < nbnd; ++i)
858 GetBndCondExpansions()[i]->GetExpSize();
862 m_session->GetFunction(
"InitialConditions", 0);
865 GetBndCondExpansions()[i]->GetNpoints();
872 m_fields[var]->GetBndCondExpansions()[i]->GetCoords(x0,x1,x2);
873 ifunc->Evaluate(x0,x1,x2,time,BDphysics);
876 for (e = 0; e < numBDEdge ; ++e)
879 GetBndCondExpansions()[i]->GetExp(e)->GetNumPoints(0);
882 GetBndCondExpansions()[i]->GetPhys_Offset(e);
886 GetBndCondTraceToGlobalTraceMap(cnt++));
890 if(
m_fields[var]->GetBndConditions()[i]->
896 &penaltyflux[id2], 1);
899 else if((
m_fields[var]->GetBndConditions()[i])->
905 &penaltyflux[id2], 1);
934 ASSERTL0(
false,
"Not defined for this class");
957 int phystot =
m_fields[0]->GetTotPoints();
958 int nvel = vel.num_elements();
964 for(
int n = 1; n < nvel; ++n)
966 Vmath::Vvtvp(phystot,vel[n],1,vel[n],1,varcoeff,1,varcoeff,1);
970 for(
int i = 0; i <
m_fields[0]->GetNumElmts(); ++i)
972 int offset =
m_fields[0]->GetPhys_Offset(i);
973 int nq =
m_fields[0]->GetExp(i)->GetTotPoints();
978 for(
int n = 0; n <
m_fields[0]->GetExp(i)->GetNumBases(); ++n)
981 m_fields[0]->GetExp(i)->GetBasisNumModes(n));
987 Vmath::Smul(nq,h,varcoeff+offset,1,tmp = varcoeff+offset,1);
virtual SOLVER_UTILS_EXPORT bool v_SteadyStateCheck(int step)
virtual SOLVER_UTILS_EXPORT void v_DoSolve()
Solves an unsteady problem.
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &l)
Virtual function for generating summary information.
#define ASSERTL0(condition, msg)
bool m_explicitReaction
Indicates if explicit or implicit treatment of reaction is used.
virtual SOLVER_UTILS_EXPORT void v_NumFluxforVector(const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate(int step)
A base class for describing how to solve specific equations.
bool m_homoInitialFwd
Flag to determine if simulation should start in homogeneous forward transformed state.
Adams-Bashforth Forward multi-step scheme of order 2.
NekDouble m_time
Current time of simulation.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Runge-Kutta multi-stage scheme 4th order explicit (old name)
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
NekDouble m_timestep
Time step size.
std::vector< std::pair< std::string, std::string > > SummaryList
void WeakPenaltyforVector(const int var, const int dir, const Array< OneD, const NekDouble > &physfield, Array< OneD, NekDouble > &penaltyflux, NekDouble C11, NekDouble time=0.0)
Classical RungeKutta4 method (new name for eClassicalRungeKutta4)
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D(Array< OneD, Array< OneD, NekDouble > > &solution1D)
Print the solution at each solution point in a txt file.
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
virtual SOLVER_UTILS_EXPORT NekDouble v_GetTimeStep(const Array< OneD, const Array< OneD, NekDouble > > &inarray)
Return the timestep to be used for the next step in the time-marching loop.
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans()
NekDouble m_checktime
Time between checkpoints.
SOLVER_UTILS_EXPORT void CheckForRestartTime(NekDouble &time, int &nchk)
const char *const TimeIntegrationMethodMap[]
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator()
Get the maximum timestep estimator for cfl control.
Nonlinear SSP RungeKutta3 explicit.
int m_nchk
Number of checkpoints written so far.
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
int m_checksteps
Number of steps between checkpoints.
NekDouble m_fintime
Finish time of the simulation.
virtual SOLVER_UTILS_EXPORT void v_InitObject()
Initialisation object for EquationSystem.
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff(const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h t...
int m_steps
Number of steps to take.
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
Classical RungeKutta2 method (new name for eMidpoint)
static const NekDouble kNekZeroTol
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem()
Destructor.
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate(int step)
Adams-Bashforth Forward multi-step scheme of order 1.
std::map< StdRegions::VarCoeffType, Array< OneD, NekDouble > > VarCoeffMap
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
int Nnan(int n, const T *x, const int incx)
Return number of NaN elements of x.
std::vector< std::pair< std::string, FilterParams > > FilterMap
Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)
Improved RungeKutta2 explicit (old name meaning Heun's method)
int m_spacedim
Spatial dimension (>= expansion dim).
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Map to identify relevant solver info to dump in output fields.
std::string PortablePath(const boost::filesystem::path &path)
create portable path on different platforms for boost::filesystem path
boost::shared_ptr< FieldIO > FieldIOSharedPtr
TimeIntegrationWrapperFactory & GetTimeIntegrationWrapperFactory()
virtual SOLVER_UTILS_EXPORT void v_InitObject()
Init object for UnsteadySystem class.
SOLVER_UTILS_EXPORT NekDouble GetTimeStep()
NekDouble m_cflSafetyFactor
CFL safety factor (comprise between 0 to 1).
virtual SOLVER_UTILS_EXPORT void v_NumFluxforScalar(const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)
boost::shared_ptr< Equation > EquationSharedPtr
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
virtual SOLVER_UTILS_EXPORT void v_NumericalFlux(Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)
SOLVER_UTILS_EXPORT int GetPhys_Offset(int n)
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
static boost::shared_ptr< FieldIO > CreateForFile(const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
Construct a FieldIO object for a given input filename.
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
SOLVER_UTILS_EXPORT int GetTraceNpoints()
LibUtilities::TimeIntegrationWrapperSharedPtr m_intScheme
Wrapper to the time integration scheme.
int m_initialStep
Number of the step where the simulation should begin.
FilterFactory & GetFilterFactory()
std::vector< FilterSharedPtr > m_filters
int m_infosteps
Number of time steps between outputting status information.
SOLVER_UTILS_EXPORT void SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Initialise the data in the dependent fields.
void WeakPenaltyforScalar(const int var, const Array< OneD, const NekDouble > &physfield, Array< OneD, NekDouble > &penaltyflux, NekDouble time=0.0)
midpoint method (old name)
NekDouble TimePerTest(unsigned int n)
Returns amount of seconds per iteration in a test with n iterations.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
static FieldMetaDataMap NullFieldMetaDataMap
LibUtilities::TimeIntegrationSolutionSharedPtr m_intSoln
virtual SOLVER_UTILS_EXPORT void v_DoInitialise()
Sets up initial conditions.
enum HomogeneousType m_HomogeneousType
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
std::vector< int > m_intVariables