rocstar_driver.C File Reference

#include <fstream>
#include <limits>
#include <cstdlib>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "rocman.h"
#include "builtin_couplings.h"
#include "derived_couplings.h"

Include dependency graph for rocstar_driver.C:

Go to the source code of this file.

Macros
#define	COM_DOUBLE_ATTRIBUTE(attrname, varname)
#define	COM_INT_ATTRIBUTE(attrname, varname)
#define	COM_STRING_ATTRIBUTE(attrname, varname)
#define	COM_BOOL_ATTRIBUTE(attrname, varname)

Functions
	COM_EXTERN_MODULE (Rocin)
	COM_EXTERN_MODULE (Rocout)
void	init_profiling (Control_parameters &param, int comm_rank)
void	RocstarShutdown (int=0)
double	get_restart_time (const string &restart_file)
Coupling *	create_coupling (Control_parameters &param, const RocmanControl_parameters &rocman_param)
bool	reached_simulation_time (const Control_parameters &param)
bool	reached_restartdump_time (Control_parameters &param)
bool	reached_visdump_time (const Control_parameters &param)
int	check_for_interrupt (Coupling *coup, const Control_parameters &param)
void	rocstar_driver (int verb, int remeshed, bool debug)
void	debug_print (const std::string str, int pane, int pe, MPI_Comm comm, const char *memo)
void	debug_int_print (const std::string str, int pane, int pe, MPI_Comm comm, const char *memo)

Variables
int	man_verbose = 1

Detailed Description

• implements rocstar_driver() the main driver of the rocstar program

Definition in file rocstar_driver.C.

Macro Definition Documentation

#define COM_BOOL_ATTRIBUTE	(		attrname,
			varname
	)

Value:

attr = winname+"."+attrname;                    \
  COM_new_attribute( attr.c_str(),'w',COM_BOOL,1,"");   \
  COM_set_size( attr.c_str(),0,1);                      \
  COM_set_array( attr.c_str(),0,&varname);

Definition at line 159 of file rocstar_driver.C.

Referenced by Control_parameters::read(), and RocmanControl_parameters::read().

#define COM_DOUBLE_ATTRIBUTE	(		attrname,
			varname
	)

Value:

attr = winname+"."+attrname;            \
  COM_new_attribute( attr.c_str(),'w',COM_DOUBLE,1,"");         \
  COM_set_size( attr.c_str(),0,1);                              \
  COM_set_array( attr.c_str(),0, &varname);

Definition at line 141 of file rocstar_driver.C.

Referenced by Control_parameters::read(), and RocmanControl_parameters::read().

#define COM_INT_ATTRIBUTE	(		attrname,
			varname
	)

Value:

attr = winname+"."+attrname;            \
  COM_new_attribute( attr.c_str(),'w',COM_INT,1,"");    \
  COM_set_size( attr.c_str(),0,1);      \
  COM_set_array( attr.c_str(),0, &varname);

Definition at line 147 of file rocstar_driver.C.

Referenced by Control_parameters::read(), and RocmanControl_parameters::read().

#define COM_STRING_ATTRIBUTE	(		attrname,
			varname
	)

Value:

attr = winname+"."+attrname;                    \
  COM_new_attribute( attr.c_str(),'w',COM_CHAR,1,"");   \
  COM_set_size( attr.c_str(),0,MAXLEN);                 \
  COM_set_array( attr.c_str(),0,varname,MAXLEN);

Definition at line 153 of file rocstar_driver.C.

Referenced by Control_parameters::read().

Function Documentation

int check_for_interrupt	(	Coupling *	coup,
		const Control_parameters &	param
	)

Definition at line 534 of file rocstar_driver.C.

References Control_parameters::communicator, Coupling::Interrupt(), and Control_parameters::myRank.

Referenced by rocstar_driver().

{
  int interrupt_code = 0;
  std::string message("Interrupted by file");
  //  std::string therest;
  if(param.myRank == 0) {
    std::ifstream InterruptFile;
    InterruptFile.open("RocstarInterrupt.txt");
    if(InterruptFile){
      std::cout << "Rocstar: Processing interrupt from file." << std::endl;
      InterruptFile >> interrupt_code;
      std::getline(InterruptFile,message);
      InterruptFile.close();
      unlink("RocstarInterrupt.txt");
      std::ofstream InterruptOut;
      InterruptOut.open("RocstarInterrupt.txt.processed");
      InterruptOut << interrupt_code << " " << message << std::endl;
      InterruptOut.close();
    }
  }
  MPI_Bcast(&interrupt_code,1,MPI_INTEGER,0,param.communicator);
  if(interrupt_code > 0){
    coup->Interrupt(&interrupt_code,message.c_str());
    return(interrupt_code);
  }
  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

COM_EXTERN_MODULE

(

Rocin

)

COM_EXTERN_MODULE

(

Rocout

)

Coupling* create_coupling	(	Control_parameters &	param,
		const RocmanControl_parameters &	rocman_param
	)

Definition at line 95 of file rocstar_driver.C.

References Control_parameters::burn_module, COM_assertion_msg, COM_LOAD_MODULE_STATIC_DYNAMIC, Control_parameters::communicator, Control_parameters::coupling_scheme, Control_parameters::fluid_module, and Control_parameters::solid_module.

Referenced by rocstar_driver().

                                                                                                    {
  const std::string &name = param.coupling_scheme;

  if ( name == "FluidAlone")
    return new FluidAlone( param.fluid_module, param.communicator, &param, &rocman_param);
  else if ( name == "FluidBurnAlone")
    return new FluidBurnAlone( param.fluid_module, param.burn_module, param.communicator, &param, &rocman_param);
  else if ( name == "SolidAlone") 
    return new SolidAlone( param.solid_module, param.communicator, &param, &rocman_param);
  else if ( name == "SolidBurn") 
    return new SolidBurn( param.solid_module, param.burn_module, param.communicator, &param, &rocman_param);
  else if ( name == "SolidFluidSPC") 
    return new SolidFluidSPC( param.fluid_module, param.solid_module, param.communicator, &param, &rocman_param);
  else if ( name == "FluidSolidISS") 
    return new FluidSolidISS( param.fluid_module, param.solid_module, param.communicator, &param, &rocman_param);
  else if ( name == "SolidFluidBurnSPC") 
    return new SolidFluidBurnSPC( param.fluid_module, param.solid_module, param.burn_module, param.communicator, &param, &rocman_param);
  else if ( name == "SolidFluidBurnEnergySPC") 
    return new SolidFluidBurnEnergySPC( param.fluid_module, param.solid_module, param.burn_module, param.communicator, &param, &rocman_param);
  else if ( name == "Test" || name.empty()){
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocout,"OUTTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocin,"INTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocface,"FACETEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocon,"PROPCONTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocmop,"MOPTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocflu,"FLUTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocflo,"FLOTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocprop,"PROPTEST");
    COM_LOAD_MODULE_STATIC_DYNAMIC(Rocfrac,"FRACTEST");
  }
  else  {
    std::cerr << "Rocstar: ERROR: Unknown coupling scheme: " << name << std::endl;
    std::cerr << std::endl;
    std::cerr << "Rocstar: Rocstar Supported coupling schemes: " << std::endl;
    std::cerr << "Rocstar:    FluidAlone:              Fluid alone with no burn" << std::endl;
    std::cerr << "Rocstar:    FluidBurnAlone:          Fluid alone with burn" << std::endl;
    std::cerr << "Rocstar:    SolidAlone:              Solid alone with no burn" << std::endl;
    std::cerr << "Rocstar:    SolidFluidBurnSPC:       FullyCoupled simple staggered scheme with P-C" << std::endl;
    std::cerr << "Rocstar:    SolidFluidSPC:           FullyCoupled no burn" << std::endl;
    std::cerr << "Rocstar:    FluidSolidISS:           FullyCoupled no burn with improved staggered scheme" << std::endl;
    std::cerr << "Rocstar:    SolidFluidBurnEnergySPC: FullyCoupled with burn energy" << std::endl;
    COM_assertion_msg(0, "ERROR: Unknown coupling scheme!");
  }
  return NULL;
}

Here is the caller graph for this function:

void debug_int_print	(	const std::string	str,
		int	pane,
		int	pe,
		MPI_Comm	comm,
		const char *	memo
	)

Definition at line 918 of file rocstar_driver.C.

References COM_get_array(), COMMPI_Comm_rank(), and i.

{
  int comm_rank = COMMPI_Comm_rank(comm);
  if (comm_rank == pe) {
    int *vm;
    int strid, cap;
    printf("%s %s: before %p\n", str.c_str(), memo?memo:"", vm);
    COM_get_array(str.c_str(), pane, &vm, &strid, &cap);
    printf("%s %s: after %p \n", str.c_str(), memo?memo:"", vm);
    for (int i=0; i<strid*cap; i++) printf("%d ", vm[i]);
    printf("\n");
  }
}

Here is the call graph for this function:

void debug_print	(	const std::string	str,
		int	pane,
		int	pe,
		MPI_Comm	comm,
		const char *	memo
	)

Definition at line 904 of file rocstar_driver.C.

References COM_get_array(), COMMPI_Comm_rank(), and i.

{
  int comm_rank = COMMPI_Comm_rank(comm);
  if (comm_rank == pe) {
    double *vm;
    int strid, cap;
    printf("%s %s: before %p\n", str.c_str(), memo?memo:"", vm);
    COM_get_array(str.c_str(), pane, &vm, &strid, &cap);
    printf("%s %s: after %p \n", str.c_str(), memo?memo:"", vm);
    for (int i=0; i<strid*cap; i++) printf("%.17e ", vm[i]);
    printf("\n");
  }
}

Here is the call graph for this function:

double get_restart_time

(

const string &

restart_file

)

Definition at line 72 of file rocstar_driver.C.

References cimg_library::cimg::fclose(), and cimg_library::cimg::fopen().

Referenced by Control_parameters::read().

{
  int curStep = 0;
  double curTime = 0.0;
#if 0
  std::ifstream Inf;
  Inf.open(restart_file.c_str());
  if(!Inf)
    return(0.0);
  while(Inf)
    Inf >> curStep >> curTime;
  Inf.close();
#else
  FILE *fp = fopen(restart_file.c_str(), "r");
  if (fp == NULL) return 0.0;
  while (!feof(fp)) {
      fscanf(fp, "%d %le", &curStep, &curTime);
  }
  fclose(fp);
#endif
  return(curTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_profiling	(	Control_parameters &	param,
		int	comm_rank
	)

Definition at line 835 of file rocstar_driver.C.

References COMMPI_Comm_size(), Control_parameters::communicator, Control_parameters::controlVerb, Control_parameters::current_time, d, cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), i, MPI_COMM_WORLD, Control_parameters::timingDataDir, and Control_parameters::timingDataFile.

Referenced by Control_parameters::read().

{
  std::string fname = "RocstarProfile";
  int data = comm_rank;
  int u = 10;   // <0, 99>
  int c = 2;
  int numProcs = COMMPI_Comm_size( param.communicator);
  while (numProcs >= u*10) {
    u *= 10;
    c ++;
  }
  for (int i=0; i<c; i++) {
    int d = data / u;
    data %= u;
    u /= 10;
    fname += ('0'+d);
  }
  fname += ".txt";
  param.timingDataFile = param.timingDataDir;
  param.timingDataFile += fname;

  int status = 1;  // new
  FILE *fd;
  if (param.current_time == 0.0) {
    fd = fopen( param.timingDataFile.c_str(), "w");
  }
  else {
    fd = fopen( param.timingDataFile.c_str(), "r");
    if (fd == NULL)
      fd = fopen( param.timingDataFile.c_str(), "w");
    else
      status = 0;    // old
  }
  if (fd == NULL) {
    param.timingDataFile = "./";
    param.timingDataFile += fname;
    if (param.current_time == 0) {
      fd = fopen( param.timingDataFile.c_str(), "w");
    }
    else {
      fd = fopen( param.timingDataFile.c_str(), "r");
      if (fd == NULL)
        fd = fopen( param.timingDataFile.c_str(), "w");
      else
        status = 0;
    }
    if (fd == NULL) {
      std::cerr << "Rocstar: Rank " << comm_rank << " could not open " 
                << param.timingDataFile.c_str() << "!" << std::endl;
      MPI_Abort( MPI_COMM_WORLD, -1);
    }
    else if(param.controlVerb > 1) 
      printf("Rocstar: Rank %d using %s instead for timing data!\n", comm_rank, param.timingDataFile.c_str());
  }

  int NumProcs;
  NumProcs = COMMPI_Comm_size( param.communicator);

  if (param.current_time == 0.0 || status == 1) {
    fprintf(fd, "\n");
    fprintf(fd, "Number of processors = %d\n", NumProcs);
    fprintf(fd, "\n");
    fprintf(fd, "MyId = %d\n", comm_rank);
    fprintf(fd, "\n");
  }
  fclose(fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool reached_restartdump_time

(

Control_parameters &

param

)

Definition at line 519 of file rocstar_driver.C.

References Control_parameters::current_time, Control_parameters::iOutput, MAN_DEBUG, Control_parameters::myRank, Control_parameters::outputIntervalTime, and Control_parameters::time_step.

Referenced by rocstar_driver().

                                                          {
  bool result =  param.current_time + param.time_step*0.4 >= 
           param.iOutput*param.outputIntervalTime;
  if (result == true) {
    param.iOutput++;
    if(param.myRank == 0) 
      MAN_DEBUG(1, ("\nRocstar: reached_restartdump_time with current_time: %e time_step: %e iOutput: %d outputIntervalTime: %e\n", param.current_time, param.time_step, param.iOutput, param.outputIntervalTime));
  }
  return result;
}

Here is the caller graph for this function:

bool reached_simulation_time

(

const Control_parameters &

param

)

Definition at line 477 of file rocstar_driver.C.

References Control_parameters::communicator, Control_parameters::controlVerb, Control_parameters::cur_step, Control_parameters::current_dump, Control_parameters::current_time, MAN_DEBUG, Control_parameters::maxNumDumps, Control_parameters::maxNumTimeSteps, Control_parameters::maxwalltime, Control_parameters::myRank, Control_parameters::simue_time, and Control_parameters::startTime.

Referenced by rocstar_driver().

                                                               {
    // if exceed max num of steps
  if (param.cur_step>=param.maxNumTimeSteps) {
    MAN_DEBUG(2, ("\nRocstar: reached_simulation_time returns TRUE with cur_step: %d\n", param.cur_step));
    return true;
  }

  int verb = param.controlVerb;

    // if exceed max wall time
  double startTimeLoopTime;
  if (param.myRank == 0) startTimeLoopTime = MPI_Wtime();
  MPI_Bcast( &startTimeLoopTime, 1, MPI_DOUBLE, 0, param.communicator);
  const double elaped_time = startTimeLoopTime - param.startTime;
  if (elaped_time >= param.maxwalltime ) {
    if (param.myRank == 0 && verb > 1) 
      printf("Rocstar: Quitting; elapsed wall clock time = %f\n", elaped_time);
    return true;
  }
  else {
    if (param.myRank == 0) {
      MAN_DEBUG(2, ("\nRocstar: reached_simulation_time: elapsed wall time = %f \n", elaped_time));
    }
  }

    // if exceed MaximumTime the simulation time
  if (param.current_time >= param.simue_time) {   // MaximumTime
    if (param.myRank == 0 && verb > 0)
      printf("Rocstar: Quitting; CurrentTime = %e, MaximumTime = %e\n", param.current_time, param.simue_time);
    return true;
  }

  // if exceed the Maximum Number of dumps
  if( (param.maxNumDumps > 0 ) && (param.current_dump >= param.maxNumDumps)){
    if(param.myRank == 0 && verb > 0)
      printf("Rocstar: Quitting; Reached the maximum number of dumps for this run. (%d)\n",param.current_dump);
    return true;
  }

  return false;
}

Here is the caller graph for this function:

bool reached_visdump_time

(

const Control_parameters &

param

)

Definition at line 530 of file rocstar_driver.C.

Referenced by rocstar_driver().

                                                            {
  // TODO: Implement this
  return false;
}

Here is the caller graph for this function:

void rocstar_driver	(	int	verb,
		int	remeshed,
		bool	debug
	)

Definition at line 562 of file rocstar_driver.C.

References Coupling::check_convergence(), check_for_interrupt(), COM_print_profile(), COM_set_debug(), COM_set_profiling(), COM_set_verbose(), COM_UNLOAD_MODULE_STATIC_DYNAMIC, Control_parameters::communicator, Control_parameters::controlDebug, Control_parameters::controlVerb, create_coupling(), Control_parameters::cur_step, Control_parameters::current_dump, Control_parameters::current_time, Coupling::finalize(), RocBlas::init(), Coupling::init_convergence(), Coupling::initialize(), Control_parameters::LastOutputStep, Control_parameters::LastOutputTime, MAN_DEBUG, Control_parameters::maxNumPredCorrCycles, Control_parameters::maxNumTimeSteps, min(), MPI_COMM_WORLD, Control_parameters::myRank, Control_parameters::output_module, Coupling::output_restart_files(), Coupling::output_visualization_files(), Control_parameters::print(), RocmanControl_parameters::print(), Coupling::ProcessInterrupt(), reached_restartdump_time(), reached_simulation_time(), reached_visdump_time(), Control_parameters::read(), RocmanControl_parameters::read(), Coupling::read_restart_info(), RocmanControl_parameters::remeshed, Coupling::restart_at_time(), Coupling::run(), Coupling::schedule(), cimg_library::cimg::strcasecmp(), Control_parameters::time_step, Control_parameters::timingDataFile, Coupling::update_distances(), Coupling::update_integrals(), Coupling::write_restart_info(), and Control_parameters::zoomFactor.

                                                         {
  // Read in config files to initialize param
  Control_parameters  *param_ptr = new Control_parameters;
  Control_parameters  &param = *param_ptr;
  param.read();

  int comm_rank = param.myRank;


  param.controlVerb = verb;
  param.controlDebug = debug;

  // Read in rocman config files to initialize param
  RocmanControl_parameters  *rocman_param_ptr = new RocmanControl_parameters;
  RocmanControl_parameters  &rocman_param = *rocman_param_ptr;
  rocman_param.read( param.communicator, comm_rank);
  rocman_param.remeshed = remeshed;

  if ( comm_rank == 0 ) {
    if(debug)
      printf("Rocstar: Call CouplingInitialize\n");
    if(verb > 1){
     param.print();
     rocman_param.print();
    }
    COM_set_verbose( verb);  // shift by 2 to depress first level printing
    COM_set_debug( debug);
  }

  MPI_Barrier(MPI_COMM_WORLD);
  //  if(!comm_rank)
  //    std::cout << "Rocstar: creating coupling." << std::endl;

  // Construct coupling object and schedule the actions
  Coupling *coup = create_coupling( param, rocman_param);
  if(!coup){
    if(comm_rank == 0)
      std::cerr << "Rocstar: Error: No coupling created. Exiting." << std::endl;
    return;
  }
  coup->schedule();

  //  std::cout << "Rocstar(" << comm_rank << "): coupling created." << std::endl;
  MPI_Barrier(MPI_COMM_WORLD);
  //  if(!comm_rank)
  //    std::cout << "Rocstar: All couplings created." << std::endl;
  // visualization
  //  std::string fname = std::string(param.coupling_scheme) + ".gdl";
  //  coup->print(fname.c_str());

  // Load other service modules
  RocBlas::init();
  MPI_Barrier(MPI_COMM_WORLD);
  //  if(!comm_rank)
  //    std::cout << "Rocstar: Rocblas initd." << std::endl;

   // Have Roccom profile all the calls to COM_call_function.
  COM_set_profiling( 1);
  MPI_Barrier(MPI_COMM_WORLD);
  //  if(!comm_rank)
  //    std::cout << "Rocstar: profiling set." << std::endl;

  int with_pciter = (param.maxNumPredCorrCycles > 1);
  if ( comm_rank == 0 && verb > 1) {
    std::cout << "Rocstar: The maximum number of PC-iterations is " << param.maxNumPredCorrCycles << std::endl;
  }
  
  // in case of restarting, reset cur_step and current_time from Restart.txt
  coup->read_restart_info();
  
  MPI_Barrier(MPI_COMM_WORLD);
  if(!comm_rank && debug)
    std::cout << "Rocstar: Read restart information, initializing" << std::endl;

  // call input, init and run_initactions
  coup->initialize();
  
  //  std::cout << "Rocstar(" << comm_rank << "): Coupling initialized." << std::endl;
  MPI_Barrier(MPI_COMM_WORLD);
  //  if(!comm_rank)
  //    std::cout << "Rocstar: All couplings initd" << std::endl;
  
  if ( param.current_time == 0.0) {
    MPI_Barrier(param.communicator);
    if(comm_rank == 0 && verb > 0)
      std::cout << "Rocstar: Performing time 0 dump..." << std::endl;
    coup->update_integrals( param.current_time);
    coup->update_distances( param.current_time);
    coup->output_restart_files( param.current_time);
    MPI_Barrier(param.communicator);
    if(comm_rank == 0 && debug)
      std::cout << "Rocstar: done." << std::endl;
  }
  
  MPI_Barrier(param.communicator);
  param.LastOutputTime = param.current_time;
  param.LastOutputStep = param.cur_step;
  
  if (comm_rank == 0 && verb > 0) {
    std::cout << "Rocstar: Starting with step " << param.cur_step+1 << ", at time " << param.current_time << std::endl;
  }
  
  char  header[100];
  sprintf(header, "************** Initialization times at time step %d *****************\n", param.cur_step);
  COM_print_profile( param.timingDataFile.c_str(), header);
  COM_set_profiling( 1);     // Reset profiler;

  if (param.current_time == 0.0) 
    coup->write_restart_info( param.current_time, 1);

    // March through time until either the specified maximum time or the maximum
    // number of time steps have been exceeded (whichever comes first).
  int InterfaceConverged;
  MPI_Barrier(param.communicator);
  //  if(comm_rank == 0)
  //    std::cout << "Rocstar: Preparig to step..." << std::endl;
  while ( !reached_simulation_time(param) ) {
    param.cur_step ++;

    for (int iPredCorr = 1; iPredCorr <= param.maxNumPredCorrCycles; iPredCorr++) 
    {
      if ( comm_rank == 0  && verb > 0) {
        std::cout << "Rocstar:" << std::endl
                  << "Rocstar: ================================================================" << std::endl
                  << "Rocstar: System Time Step : " << param.cur_step << "   PC(" << iPredCorr << ")" << std::endl
                  << "Rocstar: ================================================================" << std::endl
                  << "Rocstar:" << std::endl
                  << "Rocstar: CurrentTime, CurrentTimeStep";
        if(verb > 1)
          std::cout << ", ZoomFactor";
        std::cout << ": " 
                  << param.current_time << " " 
                  << param.time_step << " ";
        if(verb > 1)     
          std::cout << param.zoomFactor;
        std::cout << std::endl << "Rocstar:" << std::endl;
      }

      MPI_Barrier(param.communicator);
      //      if(comm_rank == 0)
      //        std::cout << "Rocstar: initializing convergence checking" << std::endl;
      if ( with_pciter) 
        coup->init_convergence( iPredCorr);
      MPI_Barrier(param.communicator);
      //      if(comm_rank == 0)
      //        std::cout << "Rocstar: convergence checking initialized" << std::endl;

      // invoke time integration of coupling scheme by passing in 
      // current time and desired time step and obtaining new time
      MPI_Barrier(param.communicator);
      //      if(comm_rank == 0)
      //        std::cout << "Rocstar: Running coupling.." << std::endl;
      double new_current_time = coup->run( param.current_time, param.time_step, 
                                           iPredCorr, param.zoomFactor);

      // Check for interrupt
      check_for_interrupt(coup,param);

      //      std::cout << comm_rank << ": solver done on this rank." << std::endl;
      MPI_Barrier(param.communicator);
      //      if(comm_rank == 0)
      //        std::cout << "Rocstar: coupling done." << std::endl;

      InterfaceConverged = 1;
      if ( with_pciter) 
        InterfaceConverged = coup->check_convergence();

      if ( comm_rank == 0 && debug )
        std::cout << "Rocstar:" << std::endl 
                  << "Rocstar: iPredCorr = " << iPredCorr << " is done" << std::endl;
      if ( InterfaceConverged ) {
          param.current_time = new_current_time;
          if ( comm_rank == 0 && verb > 1) 
              std::cout << "Rocstar: Success: predictor-corrector converged at time " << param.current_time << std::endl;
          break;
      }
      else { 
          if ( comm_rank == 0 && debug ) {
            std::cout << "Rocstar:" << std::endl
                      << "Rocstar: Interface has -NOT- converged!" << std::endl
                      << "Rocstar: iPredCorr = " << iPredCorr << " is done" << std::endl;
          }
      }
    }   // end of iPredCorr
    
    // New function to parse flags set by interrupt returns false if no action
    if(coup->ProcessInterrupt()) 
      continue;

    if ( !InterfaceConverged) {
      if (comm_rank == 0)
        std::cerr << "Rocstar: Disaster: predictor-corrector did not converge" << std::endl;
      MPI_Abort( MPI_COMM_WORLD, -1);
    }

#if 0
       // warm restart at step 3
    if (param.cur_step == 320) {
        static int didit = 0;     // do it only once
        if (!didit) {
          coup->restart_at_time(param.LastOutputTime, param.LastOutputStep);
          didit = 1;
          continue;               // skip the rest !
        }
    }
#endif
    
    // if reached time for restart dump
    if ( reached_restartdump_time( param) ) {
      MPI_Barrier(param.communicator);
      // Compute integrals and write them into files for conservation-check
      coup->update_integrals( param.current_time);
      coup->update_distances( param.current_time);
      
      // invoke restart output (as well as visualization data)
      if(comm_rank == 0 && verb > 0)
        std::cout << "Rocstar: Dumping restart files... " << std::endl;
      coup->output_restart_files( param.current_time);
      coup->write_restart_info( param.current_time, param.cur_step+1);
      param.LastOutputTime = param.current_time;
      param.LastOutputStep = param.cur_step;
      param.current_dump++;
      MPI_Barrier(param.communicator);
      //if(comm_rank == 0)
        //std::cout << "done." << std::endl;
    }
    else if ( reached_visdump_time( param)) {
      if(comm_rank == 0 && verb > 0)
        std::cout << "Rocstar: Dumping coupling viz files." << std::endl;
      // output visualization files
      coup->output_visualization_files( param.current_time);
    }

      // Write out profile data
    if ( param.cur_step <= 100 || param.LastOutputTime == param.current_time) {
      sprintf(header, "************** Solver times up to time step %d since last output *********\n", param.cur_step);
      COM_print_profile( param.timingDataFile.c_str(), header);
      COM_set_profiling( 1);     // Reset profiler;
    }
    //if(comm_rank == 0)
      //std::cout << "Rocstar:" << std::endl;
  }   // end time step

    // Write final solution.
  if (param.current_time != param.LastOutputTime) {
    MPI_Barrier(param.communicator);
    if(comm_rank == 0 && verb > 0)
      std::cout << "Rocstar: Performing final dump..." << std::endl;
    coup->output_restart_files( param.current_time);
    coup->write_restart_info( param.current_time, std::min(param.cur_step, param.maxNumTimeSteps)+1);
    MPI_Barrier(param.communicator);
    if(comm_rank == 0 && debug)
      std::cout << "Rocstar: done." << std::endl;
  }

    // Finalize coupling
  coup->finalize();

#ifdef WITH_PANDA
    // unload Rocpanda to exit gracefully
  if ( strcasecmp(param.output_module, "Rocpanda") == 0) {
    MAN_DEBUG(3, ("[%d] Rocstar: unload_module Rocpanda.\n", param.myRank));
    COM_UNLOAD_MODULE_STATIC_DYNAMIC( Rocpanda, "OUT");
  }
#endif

    // Write out the final profile data
  sprintf(header, "************** Finalization times after time step %d *****************\n", param.cur_step);
  COM_print_profile( param.timingDataFile.c_str(), header);
  
  delete coup;
}

Here is the call graph for this function:

void RocstarShutdown

(

int

status = 0

)

Definition at line 59 of file rocstar_driver.C.

References COM_finalize().

Referenced by Coupling::Interrupt(), and Coupling::ProcessInterrupt().

{
  /* Finalize Roccom. */
  COM_finalize();  
#ifdef ROCPROF
  Rocprof_Finalize(true);
#endif
  /* Close down MPI. */
  MPI_Finalize();
  exit(status);
} 

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

int man_verbose = 1

Definition at line 55 of file rocstar_driver.C.

Referenced by Agent::check_convergence_help(), RocmanControl_parameters::read(), Agent::read_by_control_file(), read_file(), FluidPropagateSurface::run(), and SolidPropagateSurface_ALE::run().