sequencer.cpp

Go to the documentation of this file.

/*
 * sequencer.cpp
 *
 *  Created on: Sep 13, 2008
 *      Author: marcosm
 */

#include "sequencer.h"
#include "exception.h"
#include "hdf5dealwriter.h"
#include "conservativemethodforsystem.h"
#include "hdf5orthowriter.h"
#include "timer.h"
#include "timer.h"
#include <math.h>
#include "diffusivestep.h"
#include "flashcompositional.h"

Sequencer::Sequencer(MonitorWells &monitor_wells)
 :_monitor_wells(monitor_wells)
{
}


Sequencer::~Sequencer()
{
        // TODO Auto-generated destructor stub
}

void Sequencer::testTransport(DynamicBase &dynMod,TransportBase &transMod,double tEnd,double nOutputs)
{
  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();
  }
}

void Sequencer::alternateIteration(DynamicBase &dynMod,TransportBase &transMod,DiffusiveStep *pDiff,double tEnd,unsigned nDynIterations,unsigned nOutputs) 
{
  
  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::alternateIteration(DynamicBase &dynMod,ConservativeMethodForSystem &transMod,FlashBase &flashMod,DiffusiveStep *diff,double tEnd,double nDynIterations,double nOutputs) 
{
  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::testDynamicModule(DynamicBase &dynMod,TransportBase &transMod) 
{
  //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::alternateIterationProportionControl(CompressibleDynamic &dynMod,ConservativeMethodForSystem &transMod,FlashBase &flashMod,DiffusiveStep *diff,double tEnd,int maxTransSteps, int maxTransStepsTol, double initialDynDt,double nOutputs) 
{
  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) 
{
  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();
    }
  }
  
}

---