Sequencer Class Reference

#include <sequencer.h>

Collaboration diagram for Sequencer:

[legend]

List of all members.

Public Member Functions
	Sequencer (MonitorWells &)
virtual	~Sequencer ()
void	testDynamicModule (DynamicBase &dynMod, TransportBase &transMod)
void	testTransport (DynamicBase &dynMod, TransportBase &transMod, double tEnd, double nOutputs)
void	alternateIteration (DynamicBase &dynMod, TransportBase &transMod, DiffusiveStep *pDiff, double tEnd, unsigned nDynIterations, unsigned nOutputsPerDynIt)
void	alternateIteration (DynamicBase &dynMod, ConservativeMethodForSystem &transMod, FlashBase &flashMod, DiffusiveStep *diff, double tEnd, double nDynIterations, double nOutputs)
void	alternateIterationProportionControl (CompressibleDynamic &dynMod, ConservativeMethodForSystem &transMod, FlashBase &flashMod, DiffusiveStep *diff, double tEnd, int maxTransSteps, int maxTransStepsTol, double initialDynDt, double nOutputs)
void	diffusiveStepTest (DiffusiveStep &diff, unsigned nIt, double tEnd, unsigned nOutputs)
Private Attributes
MonitorWells &	_monitor_wells

---

Detailed Description

This class is responsible for the iteration alghorithms between the Pression module and the transport module

Definition at line 17 of file sequencer.h.

---

Constructor & Destructor Documentation

Sequencer::Sequencer

(

MonitorWells &

monitor_wells

)

Definition at line 19 of file sequencer.cpp.

 :_monitor_wells(monitor_wells)
{
}

Sequencer::~Sequencer

(

)

[virtual]

Definition at line 25 of file sequencer.cpp.

{
        // TODO Auto-generated destructor stub
}

---

Member Function Documentation

void Sequencer::alternateIteration	(	DynamicBase &	dynMod,
		ConservativeMethodForSystem &	transMod,
		FlashBase &	flashMod,
		DiffusiveStep *	diff,
		double	tEnd,
		double	nDynIterations,
		double	nOutputs
	)

Definition at line 155 of file sequencer.cpp.

{
  double dtToPlot = tEnd/nOutputs;
  double dt = tEnd/nDynIterations;
  double t=0.0;
  double timeToPlot = dtToPlot;
  flashMod.setTransport(transMod);
  flashMod.setDynamic(dynMod);
  Timer timer(PROCESSOR_TIME);


  //Set the current time for the output classes attributes
  //sprintf(str,"Simulation Time %lf",t);
  //GnuPlotAnim::getGnuPlotAnim().setTitle(str);
  HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();
  hdf5.setVariable("Time",0);

 
 
  
  //For each iteration of the dynamic module
  for (unsigned i=0;i<nDynIterations;i++)
  {
    
    //Advances the dynamic module
    dynMod.iterate(transMod);
    //Update the other modules with the information
    //of the dynamic module
    transMod.updateVelocities(dynMod);
    //if (bIsCompressible)
    //  transMod.updateBoundaryValues(dynMod,flashMod);


    //compute the default time step for
    //the transport. This computation usually depends
    //of the dynamic module data already updated for
    //the transport modules.
    double dtTrans = transMod.getDt(t,t+dt);
    unsigned nIt = round(dt/dtTrans); //number of iterations

    assert( fabs(nIt*dtTrans - dt) < 1.e-10);
    printf("Transport Proportion %d\n",nIt);
    //For each iteration of the transport
    //do one flash calculation
    for (unsigned j=0;j<nIt;j++)
    {
      timer.start();
      transMod.iterateN(1,dtTrans);
      timer.end();

      
      //print Monitor well data
      _monitor_wells.outputData(t+dtTrans*(j+1),dynMod,transMod);
      
      //printf("Transport Time: %s\n",timer.printTime().c_str());
      timer.reset();
      flashMod.execute();
    }

    transMod.updateDataForDynamicModule();
    t+=dt;
    if (t >= timeToPlot)
    {
      timeToPlot+=dtToPlot;
      printf("Time: %g\n",t);
      hdf5.setVariable("Time",t);
      dynMod.printOutput();
      transMod.printOutput();
      flashMod.printOutput();
      if (diff)
        diff->printOutput();
    }
    if (diff)
    {
      diff->iterate(dt);
      flashMod.execute();
    }
  }
}

void Sequencer::alternateIteration	(	DynamicBase &	dynMod,
		TransportBase &	transMod,
		DiffusiveStep *	pDiff,
		double	tEnd,
		unsigned	nDynIterations,
		unsigned	nOutputs
	)

This method alternates sequentially the dynamic, transport and diffusive module. The later is optional. Note that for diffusive step we pass a pointer. If such pointer is NULL the method will not run the Diffusive step. The diffusive step has the same time step as the dynamic module.

Parameters:

	dynMod	The dynamic module
	transMod	The module responsible for the transport equation
	pDiff	The module responsible for diffusive step
	tEnd	The end time of the simulation. (The time always starts at 0)
	nDynIterations	Number of dynamic iterations through all the simulation
	nOutputs	Number of time, the simulator will output data.

Returns:

Definition at line 91 of file sequencer.cpp.

{
  
  Timer timer(CALENDAR_TIME);      //Lets measure the execution time
  double dt = tEnd/nDynIterations; //Get the time step of the dynamic module
  double dtToPlot = tEnd/nOutputs; //Defines the time step from plot to plot. 
  double timeToPlot = dtToPlot;    //When its time to plot
  double t=0.0;
  //printf("dt=%g\ndt2=%g\n",dt,dtToPlot);
  //Set the current time for the output classes attributes
  //sprintf(str,"Simulation Time %lf",t);
  //GnuPlotAnim::getGnuPlotAnim().setTitle(str);


  //Get the HDF5 class to print to hdf file. 
  HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();
  //Set the time to plot
  hdf5.setVariable("Time",0);

 
  
  //Iterate the dynamic module
  for (unsigned i=0;i<nDynIterations;i++)
  {

    timer.start(); //Start to count the time

    dynMod.iterate(transMod); //Advance the dynamic module

    timer.end();  //Plot the time
    printf("Dyn Mod Time: %s\n",timer.printTime().c_str());


    //Now advande the transport module
    //First get the velocities from the dynamic module
    transMod.updateVelocities(dynMod);

    timer.start();
    double dtTrans = transMod.getDt(t,t+dt);
    unsigned nIt = round(dt/dtTrans); //number of iterations
    transMod.iterateN(nIt,dtTrans);
    timer.end();
    printf("Transport Time: %s\n",timer.printTime().c_str());
    printf("Transport Proportion: %u\n",nIt);
    if(pDiff)
      pDiff->iterate(dt);

    t+=dt;

    if (t >= timeToPlot)
    {
      hdf5.setVariable("Time",t);
      //Advances the dynamic module
      printf("Time Before plot %g\n",t);
      transMod.printOutput();
      dynMod.printOutput();
      if(pDiff)
        pDiff->printOutput();
      timeToPlot+=dtToPlot;
    }
  }
}

void Sequencer::alternateIterationProportionControl	(	CompressibleDynamic &	dynMod,
		ConservativeMethodForSystem &	transMod,
		FlashBase &	flashMod,
		DiffusiveStep *	diff,
		double	tEnd,
		int	maxTransSteps,
		int	maxTransStepsTol,
		double	initialDynDt,
		double	nOutputs
	)

This method do basically the same staggered alghorithm then the alternateIteration method. The only difference is that now this sequencer try to control how many transport steps we iterate per Dynamic Iteration. Note that the transport module set the time step according to the CFL condition and the former is controlled by the Dynamic Module. So we dont know how much dynamic iterations we will have through the simulation before hand. The solution is a tentative and error approach. We start with a dynamic time step (initialDynDt) and then calculate the transport time step. If the number of iterations is greater than maxTransSteps + maxTransStepsTol we rollback by recalculating the dynamic step such that we might have maxTransSteps per iteration.

Parameters:

	dynMod	Dynamic Module
	transMod	Transport Module
	flashMod	Flash Module
	tEnd	End Time
	maxTransSteps	Number of transport steps for each dynamic step
	maxTransStepsTol	Tolerance for maximum transport steps per dynamic step.
	initialDynDt	Initial time step to try for the Dynamic Module
	bIsCompressible	If the model is compressible
	nOutputs	Number of time the program outputs data

Definition at line 286 of file sequencer.cpp.

{
  double dtToPlot = tEnd/nOutputs;
  double t=0.0;
  double timeToPlot = dtToPlot;
  flashMod.setTransport(transMod);
  flashMod.setDynamic(dynMod);
  double dtDyn = initialDynDt;
  //Set the current time for the output classes attributes
  //sprintf(str,"Simulation Time %lf",t);
  //GnuPlotAnim::getGnuPlotAnim().setTitle(str);
  HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();
  hdf5.setVariable("Time",0);
  int transSteps=0;
  double dtTrans;
  unsigned nTries=0;
  
  
  //For each iteration of the dynamic module
  while (t < tEnd)
  {
    

    while(1)
    {
      //Advances the dynamic module
      dynMod.setDt(dtDyn);
      dynMod.iterate(transMod);



      //Update the other modules with the information
      //of the dynamic module
      transMod.updateVelocities(dynMod);

    
    
    
      //compute the default time step for
      //the transport. This computation usually depends
      //of the dynamic module data already updated for
      //the transport modules.
      double dtCFL = transMod.getDt(t,INFINITY);


      //Get how many transport iterations we need
      int nRealTransSteps = ceil(dtDyn/dtCFL);


      printf("Sequencer Alghorithm\n");
      printf("\tdtDyn = %g, dtCFL = %g\n",dtDyn,dtCFL);
      printf("\tWe need %d transport steps",nRealTransSteps);
      
      
      
      if (nRealTransSteps <= maxTransSteps+maxTransStepsTol)
      {
        //Ok time to iterate the transport
        transSteps=nRealTransSteps;
        dtTrans=dtDyn/transSteps;
        assert(dtTrans<=dtCFL);
        dtDyn=dtCFL*maxTransSteps;
        printf("\tAproved in %d tentatives\n",nTries); 
        printf("\tdtTrans adjusted to %g\n",dtTrans);
        //dynMod.printOutput();
        //transMod.printOutput();
        //printf("\tNext dtDyn is %g\n",dtDyn);
        nTries=0;
        break;
      }
      else //rollback and calculate pressure equation again
      {
        //printf("\tNot Aproved\n");
        dynMod.rollback();
        dtDyn=dtCFL*maxTransSteps;
        //printf("\tNext dtDyn is %g\n",dtDyn);
        nTries++;
      }
    }      
    
    
    //For each iteration of the transport
    //do one flash calculation
    for (int j=0;j<transSteps;j++)
    {
      transMod.iterateN(1,dtTrans);
      flashMod.execute();
      t+=dtTrans;
      if (t >= timeToPlot)
      {
        timeToPlot+=dtToPlot;
        printf("Time: %g\n",t);
        hdf5.setVariable("Time",t);
        dynMod.printOutput();
        transMod.printOutput();
        flashMod.printOutput();
      }
    }
    if (diff)
    {
      diff->iterate(dtDyn);
      flashMod.execute();
    }
    transMod.updateDataForDynamicModule();
  }
}

void Sequencer::diffusiveStepTest	(	DiffusiveStep &	diff,
		unsigned	nIt,
		double	tEnd,
		unsigned	nOutputs
	)

Definition at line 395 of file sequencer.cpp.

{
  double dt = tEnd/nIt;
  double dtToPlot = tEnd/nOutputs;
  double timeToPlot = dtToPlot;
  double t=0.0;
  printf("dt=%g\ndt2=%g\n",dt,dtToPlot);
  //Set the current time for the output classes attributes
  //sprintf(str,"Simulation Time %lf",t);
  //GnuPlotAnim::getGnuPlotAnim().setTitle(str);
  HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();

  hdf5.setVariable("Time",0);

 
  
  //Iterate the dynamic module
  for (unsigned i=0;i<nIt;i++)
  {
    diff.iterate(dt);
    
    
    t+=dt;

    if (t >= timeToPlot)
    {
      hdf5.setVariable("Time",t);
      diff.printOutput();
    }
  }
  
}

void Sequencer::testDynamicModule	(	DynamicBase &	dynMod,
		TransportBase &	transMod
	)

Definition at line 236 of file sequencer.cpp.

{
  //Set the current time for the output classes attributes
  //sprintf(str,"Simulation Time %lf",t);
  //GnuPlotAnim::getGnuPlotAnim().setTitle(str);
  HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();
  hdf5.setVariable("Time",0);

  //GnuPlotAnim &plot = GnuPlotAnim::getGnuPlotAnim();
  //plot.setTitle("Time = 0");
  Timer time(CALENDAR_TIME);

  time.start();
  dynMod.iterate(transMod);
  time.end();
  printf("Time spent in the Dynamic Module: %s\n",time.printTime().c_str());

  
  dynMod.printOutput();
  
  return;
  
}

void Sequencer::testTransport	(	DynamicBase &	dynMod,
		TransportBase &	transMod,
		double	tEnd,
		double	nOutputs
	)

This method is used mainly to test the transport. It runs the DynamicModule just once to get a velocity field, then it iterates the transport module until the end of the simulation using this velocity field freezed in the time step 0.

Parameters:

	tEnd	Final time
	nOutputs	Number of data outputs of the transport module
	dynMod	Dynamic Module to be runned
	transMod	Transport Module to be runned

Returns:

Definition at line 40 of file sequencer.cpp.

{
  char str[500];
  double dt = tEnd/nOutputs;
  double t=0.0;

  //dynMod.printOutput();
  //throw new Exception("FIM");
  //Advances the dynamic module
  dynMod.iterate(transMod);
  transMod.updateVelocities(dynMod);
  dynMod.printOutput();
  

 
  
  //Iterate the transport
  for (unsigned i=0;i<nOutputs;i++)
  {
    Timer time(PROCESSOR_TIME);
    time.start();
    double dtTrans = transMod.getDt(t,t+dt);
    unsigned nIt = round(dt/dtTrans); //number of iterations
    transMod.iterateN(nIt,dtTrans);
    time.end();
    printf("Time spent in the transport: %s\n",time.printTime().c_str());


    t+=dt;

    //Set the current time for the output classes attributes
    sprintf(str,"Simulation Time %lf",t);
    HDF5OrthoWriter &hdf5 = HDF5OrthoWriter::getHDF5OrthoWriter();

    hdf5.setVariable("Time",t);

    transMod.printOutput();
  }
}

---

Member Data Documentation

MonitorWells& Sequencer::_monitor_wells [private]

Definition at line 20 of file sequencer.h.

---

The documentation for this class was generated from the following files:

• sequencer.h
• sequencer.cpp