Nektar++
UnsteadySystem.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File UnsteadySystem.cpp
4 //
5 // For more information, please see: http://www.nektar.info
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a
14 // copy of this software and associated documentation files (the "Software"),
15 // to deal in the Software without restriction, including without limitation
16 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 // and/or sell copies of the Software, and to permit persons to whom the
18 // Software is furnished to do so, subject to the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be included
21 // in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 // DEALINGS IN THE SOFTWARE.
30 //
31 // Description: Generic timestepping for Unsteady solvers
32 //
33 ///////////////////////////////////////////////////////////////////////////////
34 
35 #include <iomanip>
36 #include <iostream>
37 using namespace std;
38 
39 #include <boost/core/ignore_unused.hpp>
40 #include <boost/format.hpp>
41 
46 
47 namespace Nektar
48 {
49 namespace SolverUtils
50 {
51 /**
52  * @class UnsteadySystem
53  *
54  * Provides the underlying timestepping framework for unsteady solvers
55  * including the general timestepping routines. This class is not
56  * intended to be directly instantiated, but rather is a base class
57  * on which to define unsteady solvers.
58  *
59  * For details on implementing unsteady solvers see
60  * \ref sectionADRSolverModuleImplementation here
61  */
62 
63 /**
64  * Processes SolverInfo parameters from the session file and sets up
65  * timestepping-specific code.
66  * @param pSession Session object to read parameters from.
67  */
68 UnsteadySystem::UnsteadySystem(
71  : EquationSystem(pSession, pGraph), m_infosteps(10)
72 
73 {
74 }
75 
76 /**
77  * Initialization object for UnsteadySystem class.
78  */
79 void UnsteadySystem::v_InitObject(bool DeclareField)
80 {
81  EquationSystem::v_InitObject(DeclareField);
82 
83  m_initialStep = 0;
84 
85  // Load SolverInfo parameters
86  m_session->MatchSolverInfo("DIFFUSIONADVANCEMENT", "Explicit",
87  m_explicitDiffusion, true);
88  m_session->MatchSolverInfo("ADVECTIONADVANCEMENT", "Explicit",
89  m_explicitAdvection, true);
90  m_session->MatchSolverInfo("REACTIONADVANCEMENT", "Explicit",
91  m_explicitReaction, true);
92 
93  m_session->MatchSolverInfo("FLAGIMPLICITITSSTATISTICS", "True",
95 
96  m_session->LoadParameter("CheckAbortSteps", m_abortSteps, 1);
97  // Steady state tolerance
98  m_session->LoadParameter("SteadyStateTol", m_steadyStateTol, 0.0);
99  // Frequency for checking steady state
100  m_session->LoadParameter("SteadyStateSteps", m_steadyStateSteps, 1);
101 
102  // For steady problems, we do not initialise the time integration
103  if (m_session->DefinesSolverInfo("TimeIntegrationMethod") ||
104  m_session->DefinesTimeIntScheme())
105  {
107  if (m_session->DefinesTimeIntScheme())
108  {
109  timeInt = m_session->GetTimeIntScheme();
110  }
111  else
112  {
113  timeInt.method = m_session->GetSolverInfo("TimeIntegrationMethod");
114  }
115 
116  m_intScheme =
118  timeInt.method, timeInt.variant, timeInt.order,
119  timeInt.freeParams);
120 
121  // Load generic input parameters
122  m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
123  m_session->LoadParameter("IO_FiltersInfoSteps", m_filtersInfosteps,
124  10.0 * m_infosteps);
125  m_session->LoadParameter("CFL", m_cflSafetyFactor, 0.0);
126  m_session->LoadParameter("CFLEnd", m_CFLEnd, 0.0);
127  m_session->LoadParameter("CFLGrowth", m_CFLGrowth, 1.0);
128  m_session->LoadParameter("CFLGrowth", m_CFLGrowth, 1.0);
129 
130  // Time tolerance between filter update time and time integration
131  m_session->LoadParameter("FilterTimeWarning", m_filterTimeWarning, 1);
132 
133  // Ensure that there is no conflict of parameters
134  if (m_cflSafetyFactor > 0.0)
135  {
136  // Check final condition
137  ASSERTL0(m_fintime == 0.0 || m_steps == 0,
138  "Final condition not unique: "
139  "fintime > 0.0 and Nsteps > 0");
140  // Check timestep condition
141  ASSERTL0(m_timestep == 0.0,
142  "Timestep not unique: timestep > 0.0 & CFL > 0.0");
143  }
144  else
145  {
146  ASSERTL0(m_timestep != 0.0, "Need to set either TimeStep or CFL");
147  }
148 
149  // Ensure that there is no conflict of parameters
150  if (m_CFLGrowth > 1.0)
151  {
152  // Check final condition
154  "m_CFLEnd >= m_cflSafetyFactor required");
155  }
156 
157  // Set up time to be dumped in field information
158  m_fieldMetaDataMap["Time"] = boost::lexical_cast<std::string>(m_time);
159  }
160 
161  // By default attempt to forward transform initial condition.
162  m_homoInitialFwd = true;
163 
164  // Set up filters
165  for (auto &x : m_session->GetFilters())
166  {
167  m_filters.push_back(make_pair(
168  x.first, GetFilterFactory().CreateInstance(
169  x.first, m_session, shared_from_this(), x.second)));
170  }
171 }
172 
173 /**
174  * Destructor for the class UnsteadyAdvection.
175  */
177 {
178 }
179 
180 /**
181  * @brief Returns the maximum time estimator for CFL control.
182  */
184 {
185  return m_intScheme->GetTimeStability();
186 }
187 
188 /**
189  * @brief Initialises the time integration scheme (as specified in the
190  * session file), and perform the time integration.
191  */
193 {
194  ASSERTL0(m_intScheme != 0, "No time integration scheme.");
195 
196  int i = 1;
197  int nvariables = 0;
198  int nfields = m_fields.size();
199 
200  if (m_intVariables.empty())
201  {
202  for (i = 0; i < nfields; ++i)
203  {
204  m_intVariables.push_back(i);
205  }
206  nvariables = nfields;
207  }
208  else
209  {
210  nvariables = m_intVariables.size();
211  }
212 
213  // Integrate in wave-space if using homogeneous1D
215  {
216  for (i = 0; i < nfields; ++i)
217  {
218  m_fields[i]->HomogeneousFwdTrans(m_fields[i]->GetPhys(),
219  m_fields[i]->UpdatePhys());
220  m_fields[i]->SetWaveSpace(true);
221  m_fields[i]->SetPhysState(false);
222  }
223  }
224 
225  // Set up wrapper to fields data storage.
226  Array<OneD, Array<OneD, NekDouble>> fields(nvariables);
227 
228  // Order storage to list time-integrated fields first.
229  for (i = 0; i < nvariables; ++i)
230  {
231  fields[i] = m_fields[m_intVariables[i]]->GetPhys();
232  m_fields[m_intVariables[i]]->SetPhysState(false);
233  }
234 
235  // Initialise time integration scheme
236  m_intScheme->InitializeScheme(m_timestep, fields, m_time, m_ode);
237 
238  // Initialise filters
239  for (auto &x : m_filters)
240  {
241  x.second->Initialise(m_fields, m_time);
242  }
243 
244  LibUtilities::Timer timer;
245  bool doCheckTime = false;
246  int step = m_initialStep;
247  int stepCounter = 0;
248  int restartStep = -1;
249  NekDouble intTime = 0.0;
250  NekDouble cpuTime = 0.0;
251  NekDouble cpuPrevious = 0.0;
252  NekDouble elapsed = 0.0;
253  NekDouble totFilterTime = 0.0;
254 
255  m_lastCheckTime = 0.0;
256 
257  m_TotNewtonIts = 0;
258  m_TotLinIts = 0;
259  m_TotImpStages = 0;
260 
261  Array<OneD, int> abortFlags(2, 0);
262  string abortFile = "abort";
263  if (m_session->DefinesSolverInfo("CheckAbortFile"))
264  {
265  abortFile = m_session->GetSolverInfo("CheckAbortFile");
266  }
267 
268  NekDouble tmp_cflSafetyFactor = m_cflSafetyFactor;
269 
271  while ((step < m_steps || m_time < m_fintime - NekConstants::kNekZeroTol) &&
272  abortFlags[1] == 0)
273  {
274  restartStep++;
275 
276  if (m_CFLGrowth > 1.0 && m_cflSafetyFactor < m_CFLEnd)
277  {
278  tmp_cflSafetyFactor =
279  min(m_CFLEnd, m_CFLGrowth * tmp_cflSafetyFactor);
280  }
281 
282  m_flagUpdatePreconMat = true;
283 
284  // Flag to update AV
285  m_CalcPhysicalAV = true;
286  // Frozen preconditioner checks
287  if (UpdateTimeStepCheck())
288  {
289  m_cflSafetyFactor = tmp_cflSafetyFactor;
290 
291  if (m_cflSafetyFactor)
292  {
293  m_timestep = GetTimeStep(fields);
294  }
295 
296  // Ensure that the final timestep finishes at the final
297  // time, or at a prescribed IO_CheckTime.
298  if (m_time + m_timestep > m_fintime && m_fintime > 0.0)
299  {
301  }
302  else if (m_checktime &&
304  {
307  doCheckTime = true;
308  }
309  }
310 
311  if (m_TimeIncrementFactor > 1.0)
312  {
313  NekDouble timeincrementFactor = m_TimeIncrementFactor;
314  m_timestep *= timeincrementFactor;
315 
316  if (m_time + m_timestep > m_fintime && m_fintime > 0.0)
317  {
319  }
320  }
321 
322  // Perform any solver-specific pre-integration steps
323  timer.Start();
324  if (v_PreIntegrate(step))
325  {
326  break;
327  }
328 
329  m_StagesPerStep = 0;
330  m_TotLinItePerStep = 0;
331 
332  ASSERTL0(m_timestep > 0, "m_timestep < 0");
333 
334  fields = m_intScheme->TimeIntegrate(stepCounter, m_timestep, m_ode);
335  timer.Stop();
336 
337  m_time += m_timestep;
338  elapsed = timer.TimePerTest(1);
339  intTime += elapsed;
340  cpuTime += elapsed;
341 
342  // Write out status information
343  if (m_session->GetComm()->GetRank() == 0 && !((step + 1) % m_infosteps))
344  {
345  cout << "Steps: " << setw(8) << left << step + 1 << " "
346  << "Time: " << setw(12) << left << m_time;
347 
348  if (m_cflSafetyFactor)
349  {
350  cout << " Time-step: " << setw(12) << left << m_timestep;
351  }
352 
353  stringstream ss;
354  ss << cpuTime << "s";
355  cout << " CPU Time: " << setw(8) << left << ss.str() << endl;
356  cpuPrevious = cpuTime;
357  cpuTime = 0.0;
358 
360  {
361  cout << " &&"
362  << " TotImpStages= " << m_TotImpStages
363  << " TotNewtonIts= " << m_TotNewtonIts
364  << " TotLinearIts = " << m_TotLinIts << endl;
365  }
366  }
367 
368  // Transform data into coefficient space
369  for (i = 0; i < nvariables; ++i)
370  {
371  // copy fields into ExpList::m_phys and assign the new
372  // array to fields
373  m_fields[m_intVariables[i]]->SetPhys(fields[i]);
374  fields[i] = m_fields[m_intVariables[i]]->UpdatePhys();
375  if (v_RequireFwdTrans())
376  {
377  m_fields[m_intVariables[i]]->FwdTransLocalElmt(
378  fields[i], m_fields[m_intVariables[i]]->UpdateCoeffs());
379  }
380  m_fields[m_intVariables[i]]->SetPhysState(false);
381  }
382 
383  // Perform any solver-specific post-integration steps
384  if (v_PostIntegrate(step))
385  {
386  break;
387  }
388 
389  // Check for steady-state
390  if (m_steadyStateTol > 0.0 && (!((step + 1) % m_steadyStateSteps)))
391  {
392  if (CheckSteadyState(step, intTime))
393  {
394  if (m_comm->GetRank() == 0)
395  {
396  cout << "Reached Steady State to tolerance "
397  << m_steadyStateTol << endl;
398  }
399  break;
400  }
401  }
402 
403  // test for abort conditions (nan, or abort file)
404  if (m_abortSteps && !((step + 1) % m_abortSteps))
405  {
406  abortFlags[0] = 0;
407  for (i = 0; i < nvariables; ++i)
408  {
409  if (Vmath::Nnan(fields[i].size(), fields[i], 1) > 0)
410  {
411  abortFlags[0] = 1;
412  }
413  }
414 
415  // rank zero looks for abort file and deltes it
416  // if it exists. The communicates the abort
417  if (m_session->GetComm()->GetRank() == 0)
418  {
419  if (boost::filesystem::exists(abortFile))
420  {
421  boost::filesystem::remove(abortFile);
422  abortFlags[1] = 1;
423  }
424  }
425 
426  m_session->GetComm()->AllReduce(abortFlags,
428 
429  ASSERTL0(!abortFlags[0], "NaN found during time integration.");
430  }
431 
432  // Update filters
433  for (auto &x : m_filters)
434  {
435  timer.Start();
436  x.second->Update(m_fields, m_time);
437  timer.Stop();
438  elapsed = timer.TimePerTest(1);
439  totFilterTime += elapsed;
440 
441  // Write out individual filter status information
442  if (m_session->GetComm()->GetRank() == 0 &&
443  !((step + 1) % m_filtersInfosteps) && !m_filters.empty() &&
444  m_session->DefinesCmdLineArgument("verbose"))
445  {
446  stringstream s0;
447  s0 << x.first << ":";
448  stringstream s1;
449  s1 << elapsed << "s";
450  stringstream s2;
451  s2 << elapsed / cpuPrevious * 100 << "%";
452  cout << "CPU time for filter " << setw(25) << left << s0.str()
453  << setw(12) << left << s1.str() << endl
454  << "\t Percentage of time integration: " << setw(10)
455  << left << s2.str() << endl;
456  }
457  }
458 
459  // Write out overall filter status information
460  if (m_session->GetComm()->GetRank() == 0 &&
461  !((step + 1) % m_filtersInfosteps) && !m_filters.empty())
462  {
463  stringstream ss;
464  ss << totFilterTime << "s";
465  cout << "Total filters CPU Time:\t\t\t " << setw(10) << left
466  << ss.str() << endl;
467  }
468  totFilterTime = 0.0;
469 
470  // Write out checkpoint files
471  if ((m_checksteps && !((step + 1) % m_checksteps)) || doCheckTime)
472  {
474  {
475  vector<bool> transformed(nfields, false);
476  for (i = 0; i < nfields; i++)
477  {
478  if (m_fields[i]->GetWaveSpace())
479  {
480  m_fields[i]->SetWaveSpace(false);
481  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
482  m_fields[i]->UpdatePhys());
483  m_fields[i]->SetPhysState(true);
484  transformed[i] = true;
485  }
486  }
488  m_nchk++;
489  for (i = 0; i < nfields; i++)
490  {
491  if (transformed[i])
492  {
493  m_fields[i]->SetWaveSpace(true);
494  m_fields[i]->HomogeneousFwdTrans(
495  m_fields[i]->GetPhys(), m_fields[i]->UpdatePhys());
496  m_fields[i]->SetPhysState(false);
497  }
498  }
499  }
500  else
501  {
503  m_nchk++;
504  }
505  doCheckTime = false;
506  }
507 
508  // Step advance
509  ++step;
510  ++stepCounter;
511  }
512 
513  // Print out summary statistics
514  if (m_session->GetComm()->GetRank() == 0)
515  {
516  if (m_cflSafetyFactor > 0.0)
517  {
518  cout << "CFL safety factor : " << m_cflSafetyFactor << endl
519  << "CFL time-step : " << m_timestep << endl;
520  }
521 
522  if (m_session->GetSolverInfo("Driver") != "SteadyState")
523  {
524  cout << "Time-integration : " << intTime << "s" << endl;
525  }
526 
528  {
529  cout << "-------------------------------------------" << endl
530  << "Total Implicit Stages: " << m_TotImpStages << endl
531  << "Total Newton Its : " << m_TotNewtonIts << endl
532  << "Total Linear Its : " << m_TotLinIts << endl
533  << "-------------------------------------------" << endl;
534  }
535  }
536 
537  // If homogeneous, transform back into physical space if necessary.
539  {
540  for (i = 0; i < nfields; i++)
541  {
542  if (m_fields[i]->GetWaveSpace())
543  {
544  m_fields[i]->SetWaveSpace(false);
545  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
546  m_fields[i]->UpdatePhys());
547  m_fields[i]->SetPhysState(true);
548  }
549  }
550  }
551  else
552  {
553  for (i = 0; i < nvariables; ++i)
554  {
555  m_fields[m_intVariables[i]]->SetPhys(fields[i]);
556  m_fields[m_intVariables[i]]->SetPhysState(true);
557  }
558  }
559 
560  // Finalise filters
561  for (auto &x : m_filters)
562  {
563  x.second->Finalise(m_fields, m_time);
564  }
565 
566  // Print for 1D problems
567  if (m_spacedim == 1)
568  {
569  v_AppendOutput1D(fields);
570  }
571 }
572 
573 /**
574  * @brief Sets the initial conditions.
575  */
577 {
582 }
583 
584 /**
585  * @brief Prints a summary with some information regards the
586  * time-stepping.
587  */
589 {
591  AddSummaryItem(s, "Advect. advancement",
592  m_explicitAdvection ? "explicit" : "implicit");
593 
594  AddSummaryItem(s, "Diffuse. advancement",
595  m_explicitDiffusion ? "explicit" : "implicit");
596 
597  if (m_session->GetSolverInfo("EQTYPE") ==
598  "SteadyAdvectionDiffusionReaction")
599  {
600  AddSummaryItem(s, "React. advancement",
601  m_explicitReaction ? "explicit" : "implicit");
602  }
603 
604  AddSummaryItem(s, "Time Step", m_timestep);
605  AddSummaryItem(s, "No. of Steps", m_steps);
606  AddSummaryItem(s, "Checkpoints (steps)", m_checksteps);
607  AddSummaryItem(s, "Integration Type", m_intScheme->GetName());
608 }
609 
610 /**
611  * Stores the solution in a file for 1D problems only. This method has
612  * been implemented to facilitate the post-processing for 1D problems.
613  */
615  Array<OneD, Array<OneD, NekDouble>> &solution1D)
616 {
617  // Coordinates of the quadrature points in the real physical space
621  m_fields[0]->GetCoords(x, y, z);
622 
623  // Print out the solution in a txt file
624  ofstream outfile;
625  outfile.open("solution1D.txt");
626  for (int i = 0; i < GetNpoints(); i++)
627  {
628  outfile << scientific << setw(17) << setprecision(16) << x[i] << " "
629  << solution1D[0][i] << endl;
630  }
631  outfile << endl << endl;
632  outfile.close();
633 }
634 
636 {
637  if (m_session->DefinesFunction("InitialConditions"))
638  {
639  for (int i = 0; i < m_fields.size(); ++i)
640  {
642 
643  vType = m_session->GetFunctionType("InitialConditions",
644  m_session->GetVariable(i));
645 
646  if (vType == LibUtilities::eFunctionTypeFile)
647  {
648  std::string filename = m_session->GetFunctionFilename(
649  "InitialConditions", m_session->GetVariable(i));
650 
651  fs::path pfilename(filename);
652 
653  // redefine path for parallel file which is in directory
654  if (fs::is_directory(pfilename))
655  {
656  fs::path metafile("Info.xml");
657  fs::path fullpath = pfilename / metafile;
658  filename = LibUtilities::PortablePath(fullpath);
659  }
662  fld->ImportFieldMetaData(filename, m_fieldMetaDataMap);
663 
664  // check to see if time defined
666  {
667  auto iter = m_fieldMetaDataMap.find("Time");
668  if (iter != m_fieldMetaDataMap.end())
669  {
670  time = boost::lexical_cast<NekDouble>(iter->second);
671  }
672 
673  iter = m_fieldMetaDataMap.find("ChkFileNum");
674  if (iter != m_fieldMetaDataMap.end())
675  {
676  nchk = boost::lexical_cast<NekDouble>(iter->second);
677  }
678  }
679 
680  break;
681  }
682  }
683  }
684  if (m_session->DefinesCmdLineArgument("set-start-time"))
685  {
686  time = boost::lexical_cast<NekDouble>(
687  m_session->GetCmdLineArgument<std::string>("set-start-time")
688  .c_str());
689  }
690  if (m_session->DefinesCmdLineArgument("set-start-chknumber"))
691  {
692  nchk = boost::lexical_cast<int>(
693  m_session->GetCmdLineArgument<std::string>("set-start-chknumber"));
694  }
695  ASSERTL0(time >= 0 && nchk >= 0,
696  "Starting time and checkpoint number should be >= 0");
697 }
698 
699 /**
700  * @brief Return the timestep to be used for the next step in the
701  * time-marching loop.
702  *
703  * This function can be overloaded to facilitate solver which utilise a
704  * CFL (or other) parameter to determine a maximum timestep under which
705  * the problem remains stable.
706  */
708  const Array<OneD, const Array<OneD, NekDouble>> &inarray)
709 {
710  return v_GetTimeStep(inarray);
711 }
712 
713 /**
714  * @brief Return the timestep to be used for the next step in the
715  * time-marching loop.
716  *
717  * @see UnsteadySystem::GetTimeStep
718  */
720  const Array<OneD, const Array<OneD, NekDouble>> &inarray)
721 {
722  boost::ignore_unused(inarray);
723  NEKERROR(ErrorUtil::efatal, "Not defined for this class");
724  return 0.0;
725 }
726 
728 {
729  boost::ignore_unused(step);
730  return false;
731 }
732 
734 {
735  boost::ignore_unused(step);
736  return false;
737 }
738 
740  const Array<OneD, Array<OneD, NekDouble>> vel,
741  StdRegions::VarCoeffMap &varCoeffMap)
742 {
743  int phystot = m_fields[0]->GetTotPoints();
744  int nvel = vel.size();
745 
746  Array<OneD, NekDouble> varcoeff(phystot), tmp;
747 
748  // calculate magnitude of v
749  Vmath::Vmul(phystot, vel[0], 1, vel[0], 1, varcoeff, 1);
750  for (int n = 1; n < nvel; ++n)
751  {
752  Vmath::Vvtvp(phystot, vel[n], 1, vel[n], 1, varcoeff, 1, varcoeff, 1);
753  }
754  Vmath::Vsqrt(phystot, varcoeff, 1, varcoeff, 1);
755 
756  for (int i = 0; i < m_fields[0]->GetNumElmts(); ++i)
757  {
758  int offset = m_fields[0]->GetPhys_Offset(i);
759  int nq = m_fields[0]->GetExp(i)->GetTotPoints();
760  Array<OneD, NekDouble> unit(nq, 1.0);
761 
762  int nmodes = 0;
763 
764  for (int n = 0; n < m_fields[0]->GetExp(i)->GetNumBases(); ++n)
765  {
766  nmodes = max(nmodes, m_fields[0]->GetExp(i)->GetBasisNumModes(n));
767  }
768 
769  NekDouble h = m_fields[0]->GetExp(i)->Integral(unit);
770  h = pow(h, (NekDouble)(1.0 / nvel)) / ((NekDouble)nmodes);
771 
772  Vmath::Smul(nq, h, varcoeff + offset, 1, tmp = varcoeff + offset, 1);
773  }
774 
775  // set up map with eVarCoffLaplacian key
776  varCoeffMap[StdRegions::eVarCoeffLaplacian] = varcoeff;
777 }
778 
780 {
781  if (m_steadyStateTol > 0.0)
782  {
783  const int nPoints = m_fields[0]->GetTotPoints();
786 
787  for (int i = 0; i < m_fields.size(); ++i)
788  {
790  Vmath::Vcopy(nPoints, m_fields[i]->GetPhys(), 1,
791  m_previousSolution[i], 1);
792  }
793 
794  if (m_comm->GetRank() == 0)
795  {
796  std::string fName =
797  m_session->GetSessionName() + std::string(".resd");
798  m_errFile.open(fName.c_str());
799  m_errFile << setw(26) << left << "# Time";
800 
801  m_errFile << setw(26) << left << "CPU_Time";
802 
803  m_errFile << setw(26) << left << "Step";
804 
805  for (int i = 0; i < m_fields.size(); ++i)
806  {
807  m_errFile << setw(26) << m_session->GetVariables()[i];
808  }
809 
810  m_errFile << endl;
811  }
812  }
813 }
814 
815 /**
816  * @brief Calculate whether the system has reached a steady state by
817  * observing residuals to a user-defined tolerance.
818  */
820 {
821  return CheckSteadyState(step, 0.0);
822 }
823 
824 bool UnsteadySystem::CheckSteadyState(int step, NekDouble totCPUTime)
825 {
826  const int nPoints = GetTotPoints();
827  const int nFields = m_fields.size();
828 
829  // Holds L2 errors.
830  Array<OneD, NekDouble> L2(nFields);
831 
832  SteadyStateResidual(step, L2);
833 
834  if (m_comm->GetRank() == 0 &&
835  (((step + 1) % m_infosteps == 0) || ((step == m_initialStep))))
836  {
837  // Output time
838  m_errFile << boost::format("%25.19e") % m_time;
839 
840  m_errFile << " " << boost::format("%25.19e") % totCPUTime;
841 
842  int stepp = step + 1;
843 
844  m_errFile << " " << boost::format("%25.19e") % stepp;
845 
846  // Output residuals
847  for (int i = 0; i < nFields; ++i)
848  {
849  m_errFile << " " << boost::format("%25.19e") % L2[i];
850  }
851 
852  m_errFile << endl;
853  }
854 
855  // Calculate maximum L2 error
856  NekDouble maxL2 = Vmath::Vmax(nFields, L2, 1);
857 
858  if (m_session->DefinesCmdLineArgument("verbose") &&
859  m_comm->GetRank() == 0 && ((step + 1) % m_infosteps == 0))
860  {
861  cout << "-- Maximum L^2 residual: " << maxL2 << endl;
862  }
863 
864  if (maxL2 <= m_steadyStateTol)
865  {
866  return true;
867  }
868 
869  for (int i = 0; i < m_fields.size(); ++i)
870  {
871  Vmath::Vcopy(nPoints, m_fields[i]->GetPhys(), 1, m_previousSolution[i],
872  1);
873  }
874 
876  m_steadyStateRes = maxL2;
877 
878  return false;
879 }
880 
882 {
883  boost::ignore_unused(step);
884  const int nPoints = GetTotPoints();
885  const int nFields = m_fields.size();
886 
887  // Holds L2 errors.
888  Array<OneD, NekDouble> RHSL2(nFields);
889  Array<OneD, NekDouble> residual(nFields);
890  Array<OneD, NekDouble> reference(nFields);
891 
892  for (int i = 0; i < nFields; ++i)
893  {
894  Array<OneD, NekDouble> tmp(nPoints);
895 
896  Vmath::Vsub(nPoints, m_fields[i]->GetPhys(), 1, m_previousSolution[i],
897  1, tmp, 1);
898  Vmath::Vmul(nPoints, tmp, 1, tmp, 1, tmp, 1);
899  residual[i] = Vmath::Vsum(nPoints, tmp, 1);
900 
901  Vmath::Vmul(nPoints, m_previousSolution[i], 1, m_previousSolution[i], 1,
902  tmp, 1);
903  reference[i] = Vmath::Vsum(nPoints, tmp, 1);
904  }
905 
906  m_comm->AllReduce(residual, LibUtilities::ReduceSum);
907  m_comm->AllReduce(reference, LibUtilities::ReduceSum);
908 
909  // L2 error
910  for (int i = 0; i < nFields; ++i)
911  {
912  reference[i] = (reference[i] == 0) ? 1 : reference[i];
913  L2[i] = sqrt(residual[i] / reference[i]);
914  }
915 }
916 
919  "set-start-time", "", "Set the starting time of the simulation.");
920 
923  "set-start-chknumber", "",
924  "Set the starting number of the checkpoint file.");
925 } // namespace SolverUtils
926 } // namespace Nektar
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209
static std::shared_ptr< FieldIO > CreateForFile(const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
Construct a FieldIO object for a given input filename.
Definition: FieldIO.cpp:227
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
static std::string RegisterCmdLineArgument(const std::string &pName, const std::string &pShortName, const std::string &pDescription)
Registers a command-line argument with the session reader.
NekDouble TimePerTest(unsigned int n)
Returns amount of seconds per iteration in a test with n iterations.
Definition: Timer.cpp:68
A base class for describing how to solve specific equations.
int m_spacedim
Spatial dimension (>= expansion dim).
LibUtilities::CommSharedPtr m_comm
Communicator.
NekDouble m_timestep
Time step size.
NekDouble m_time
Current time of simulation.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
NekDouble m_fintime
Finish time of the simulation.
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.
NekDouble m_checktime
Time between checkpoints.
SOLVER_UTILS_EXPORT NekDouble GetTimeStep()
virtual SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareFeld=true)
Initialisation object for EquationSystem.
NekDouble m_timestepMax
Time step size.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
int m_initialStep
Number of the step where the simulation should begin.
enum HomogeneousType m_HomogeneousType
SOLVER_UTILS_EXPORT int GetNpoints()
int m_nchk
Number of checkpoints written so far.
int m_steps
Number of steps to take.
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Map to identify relevant solver info to dump in output fields.
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &l)
Virtual function for generating summary information.
int m_checksteps
Number of steps between checkpoints.
SOLVER_UTILS_EXPORT void SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Initialise the data in the dependent fields.
SOLVER_UTILS_EXPORT int GetTotPoints()
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
NekDouble m_CFLGrowth
CFL growth rate.
bool m_explicitReaction
Indicates if explicit or implicit treatment of reaction is used.
virtual SOLVER_UTILS_EXPORT void v_DoInitialise()
Sets up initial conditions.
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
Storage for previous solution for steady-state check.
virtual SOLVER_UTILS_EXPORT void v_DoSolve()
Solves an unsteady problem.
bool m_CalcPhysicalAV
flag to update artificial viscosity
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
NekDouble m_cflSafetyFactor
CFL safety factor (comprise between 0 to 1).
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
Wrapper to the time integration scheme.
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem()
Destructor.
NekDouble m_filterTimeWarning
Number of time steps between outputting status information.
NekDouble m_steadyStateTol
Tolerance to which steady state should be evaluated at.
int m_abortSteps
Number of steps between checks for abort conditions.
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator()
Get the maximum timestep estimator for cfl control.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
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 void v_InitObject(bool DeclareField=true)
Init object for UnsteadySystem class.
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans()
bool CheckSteadyState(int step)
Calculate whether the system has reached a steady state by observing residuals to a user-defined tole...
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate(int step)
NekDouble m_CFLEnd
maximun cfl in cfl growth
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...
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual(int step, Array< OneD, NekDouble > &L2)
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate(int step)
SOLVER_UTILS_EXPORT void CheckForRestartTime(NekDouble &time, int &nchk)
SOLVER_UTILS_EXPORT void SteadyStateResidual(int step, Array< OneD, NekDouble > &L2)
int m_steadyStateSteps
Check for steady state at step interval.
virtual SOLVER_UTILS_EXPORT bool UpdateTimeStepCheck()
int m_filtersInfosteps
Number of time steps between outputting filters information.
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D(Array< OneD, Array< OneD, NekDouble >> &solution1D)
Print the solution at each solution point in a txt file.
int m_infosteps
Number of time steps between outputting status information.
bool m_homoInitialFwd
Flag to determine if simulation should start in homogeneous forward transformed state.
TimeIntegrationSchemeFactory & GetTimeIntegrationSchemeFactory()
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:301
std::string PortablePath(const boost::filesystem::path &path)
create portable path on different platforms for boost::filesystem path
Definition: FileSystem.cpp:41
std::shared_ptr< SessionReader > SessionReaderSharedPtr
static FieldMetaDataMap NullFieldMetaDataMap
Definition: FieldIO.h:53
static const NekDouble kNekZeroTol
std::vector< std::pair< std::string, std::string > > SummaryList
Definition: Misc.h:48
FilterFactory & GetFilterFactory()
Definition: Filter.cpp:41
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:49
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:172
std::map< StdRegions::VarCoeffType, Array< OneD, NekDouble > > VarCoeffMap
Definition: StdRegions.hpp:240
The above copyright notice and this permission notice shall be included.
Definition: CoupledSolver.h:1
double NekDouble
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Definition: Vmath.cpp:534
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.
Definition: Vmath.cpp:209
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
Definition: Vmath.cpp:574
T Vsum(int n, const T *x, const int incx)
Subtract return sum(x)
Definition: Vmath.cpp:895
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248
int Nnan(int n, const T *x, const int incx)
Return number of NaN elements of x.
Definition: Vmath.cpp:1076
T Vmax(int n, const T *x, const int incx)
Return the maximum element in x – called vmax to avoid conflict with max.
Definition: Vmath.cpp:945
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255
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.
Definition: Vmath.cpp:419
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:291
std::vector< NekDouble > freeParams
Definition: SessionReader.h:90