Method checkPoint

Source/driver/Castro_io.cpp:385–500

}

void
Castro::checkPoint(const std::string& dir,
                   std::ostream&  os,
                   VisMF::How     how,
                   bool /*dump_old_default*/)
{

  const Real io_start_time = ParallelDescriptor::second();

  AmrLevel::checkPoint(dir, os, how, dump_old);

  const Real io_time = ParallelDescriptor::second() - io_start_time;

#ifdef RADIATION
  if (do_radiation) {
    radiation->checkPoint(level, dir, os, how);
  }
#endif

#ifdef AMREX_PARTICLES
  ParticleCheckPoint(dir);
#endif

  if (level == 0 && ParallelDescriptor::IOProcessor())
    {
        {
            std::ofstream CastroHeaderFile;
            std::string FullPathCastroHeaderFile = dir;
            FullPathCastroHeaderFile += "/CastroHeader";
            CastroHeaderFile.open(FullPathCastroHeaderFile.c_str(), std::ios::out);

            CastroHeaderFile << "Checkpoint version: " << current_version << std::endl;
            CastroHeaderFile.close();

            writeJobInfo(dir, io_time);

            // output the list of state variables, so we can do a sanity check on restart
            std::ofstream StateListFile;
            std::string FullPathStateList = dir;
            FullPathStateList += "/state_names.txt";
            StateListFile.open(FullPathStateList.c_str(), std::ios::out);

            for (int n = 0; n < NUM_STATE; n++) {
              StateListFile << desc_lst[State_Type].name(n) << "\n";
            }
            StateListFile.close();
        }

        // If we have limited this last timestep to hit a plot interval,
        // store the timestep we took before limiting. After the restart,
        // this dt will be read in and used to limit the next timestep
        // appropriately, rather than the shortened timestep.

        if (lastDtPlotLimited == 1) {

            std::ofstream dtHeaderFile;
            std::string FullPathdtHeaderFile = dir;
            FullPathdtHeaderFile += "/dtHeader";