flashcompositional.cpp

Go to the documentation of this file.

#include "flashcompositional.h"
#include "numericmethods.h"
#include "arrayofvecdouble.h"



 void FlashCompositional::flash(double P, const VecDouble &compTotalMoles, FlashData &data) 
{
  throw new Exception("Invalid Method called FlashCompositional::flash(double P, double T,const VecDouble &compTotalMoles, FlashData &data)");
}

 double FlashCompositional::getFluidCompressibility(double P, FlashData &data) 
{
  return getNumericFluidCompressibility(P,data);

}

void FlashCompositional::getPhasesVolume(double P, const FlashData &data, VecDouble &phasesVol) 
{
  throw new Exception("This flash module does not override FlashCompositional::getPhasesVolume(double P, const FlashData &data, VecDouble &phasesVol)\nProbably this flash module was not designed for compositional models.\n Please check that reading the config.conf file");
}


 FlashCompositional::FlashCompositional(unsigned n_phases,unsigned n_components) :FlashBase(n_phases,n_components)
 {
    

}


 const VecDouble& FlashCompositional::getComponentsMolarMass() const 
{
  throw new Exception("This flash module does not override FlashCompositional::getComponentsMolarMass()\nProbably this flash module was not designed for compositional module.\n Please check that reading the config.conf file");

}


 void FlashCompositional::getPhasesViscosities(double P,const FlashData &data,VecDouble &visc) 
{
  throw new Exception("This flash module does not override FlashCompositional::getPhasesViscosities()\nProbably this flash module was not designed for compositional module.\n Please check that reading the config.conf file");

}

double FlashCompositional::getNumericFluidCompressibility(double P,const FlashData &data,double tol) 
{

  double h=P*tol;
  
  static FlashData data1(n_phases,n_components);
  static VecDouble totalComponents(n_components);
  static VecDouble phasesVol(n_phases);
  data1.allocateOwnMemory();
  data.getTotalComponentsMoles(totalComponents);
  

  flash(P+h,totalComponents,data1);
  getPhasesVolume(P+h,data1,phasesVol);
  double volPos=NumericMethods::vectorSum(phasesVol);
  
  flash(P-h,totalComponents,data1);
  getPhasesVolume(P-h,data1,phasesVol);
  double volNeg=NumericMethods::vectorSum(phasesVol);

  return -(volPos-volNeg)/(2*h);

}

void FlashCompositional::getNumericTotalVolumeDerivative(double P,const VecDouble &compTotalMoles,VecDouble &compTotalDeriv,double h) 
{
  static FlashData data(numPhases(),numComponents());
  static VecDouble compTotalDX;
  static VecDouble phasesVol(numPhases());
  compTotalDX=compTotalMoles;

  assert(compTotalMoles.size() == compTotalDeriv.size());

  
  for (unsigned cmp=0;cmp<numComponents();cmp++)
  {
    compTotalDX(cmp)=compTotalMoles(cmp)+h;
    flash(P,compTotalDX,data);
    getPhasesVolume(P,data,phasesVol);
    double posVol=NumericMethods::vectorSum(phasesVol);
    
    compTotalDX(cmp)=compTotalMoles(cmp)-h;
    if (compTotalDX(cmp) >= 0.0)
    {
      flash(P,compTotalDX,data);
      getPhasesVolume(P,data,phasesVol);
      double negVol=NumericMethods::vectorSum(phasesVol);
      compTotalDeriv(cmp)=(posVol-negVol)/(2*h);
      compTotalDX(cmp)=compTotalMoles(cmp);
    }
    else
    {
      compTotalDX(cmp)=compTotalMoles(cmp);
      flash(P,compTotalDX,data);
      getPhasesVolume(P,data,phasesVol);
      double negVol=NumericMethods::vectorSum(phasesVol);
      compTotalDeriv(cmp)=(posVol-negVol)/(h);
    }
      

  }
    
}
  


 void FlashCompositional::getTotalVolumeDerivatives(double P,FlashData &data,VecDouble &dv_dm) 
{
  throw new Exception("This flash module does not implement FlashCompositional:::getTotalVolumeDerivatives(double P,FlashData &data,VecDouble &dv_dm)\nProbably this flash module was not designed for compositional module.\n Please check that by reading the config.conf file");
  
}


 void FlashCompositional::printOutput() 
{
  //Empty method by default
}

void FlashCompositional::flash(Index cell, FlashData &data) 
{
   m_dataArray.getData(cell,data);
}

 void FlashCompositional::execute() 
{
  //Get pressure vector and transport module;
  const VecDouble &vP=getDynamicModule().getPressureAtCells();
  TransportBase   &trans=getTransportModule();
  assert(vP.size() == trans.getSolutionAtCells().size());
  assert(trans.getSolutionAtCells().vecs_size() == numComponents());
  //Allocate the vector of total components m
  static VecDoubleRef m(this->numComponents());

  //Initialize data if necessary
  if (m_dataArray.size() == 0)
  {
    m_dataArray.reinit(numPhases(),numComponents(),trans.getSolutionAtCells().size());
  }

  unsigned nCells = m_dataArray.size();
  FlashData data(numPhases(),numComponents(),NULL);
  for (unsigned i=0;i<nCells;i++)
  {
    m_dataArray.getData(i,data);
    trans.getSolutionAtCells().getVecValues(i,&m);
    this->flash(vP(i),m,data);
  }
}

---