flashdata.cpp

Go to the documentation of this file.

#include "flashdata.h"
#include "numericmethods.h"


 double FlashData::getMoles(unsigned phase,unsigned comp) const
{
  assert(phase<n_phases && comp <n_comps);
  assert(m_phaseCompositions);
  return m_phaseCompositions[phase*n_comps+comp];
}

void FlashData::setMoles(unsigned phase,unsigned comp,const double &value) 
{
  assert(m_phaseCompositions);
  m_phaseCompositions[phase*n_comps+comp]=value;
  
  
}



FlashData::FlashData(unsigned n_phases,unsigned n_comps,double *mem) 
   :n_phases(n_phases),n_comps(n_comps)
 {
   m_phaseCompositions=mem;
   m_Del=false;
 }

 FlashData::FlashData(unsigned n_phases,unsigned n_comps) 
   :n_phases(n_phases),n_comps(n_comps)
{
  m_Del=false;
  allocateOwnMemory();
} 


FlashData::~FlashData() 
{
  if (m_Del)
    delete [] m_phaseCompositions;
}



void FlashData::allocateOwnMemory()
{
  if (!m_Del)
  {
    m_phaseCompositions=new double[n_phases*n_comps];
    m_Del=true;
    
  }
}






double FlashData::getPhaseTotalMoles(unsigned phase) const
{
  assert(m_phaseCompositions);
  assert(phase<n_phases);
  double acum=0;
  const double *dd=&(m_phaseCompositions[phase*n_comps]);
  for (unsigned i=0;i<n_comps;i++)
  {
    acum+=*(dd++);
  }
  return acum;
}

void FlashData::getPhasesTotalMoles(VecDouble &phases) const
{
  assert(phases.size() == n_phases);
  assert(m_phaseCompositions);
  double acum;
  const double *dd=m_phaseCompositions;
  for (unsigned i=0;i<n_phases;i++)
  {
    acum=0.0;
    for (unsigned j=0;j<n_comps;j++)
    {
      acum+=*(dd++);
    }
    phases(i)=acum;
  }
}

void FlashData::getPhaseConcentrationsAndTotalMoles(Matrix &phasesC, VecDouble &phasesTM) const
{
  assert(m_phaseCompositions);
  assert(phasesC.m() == n_phases && phasesC.n() == n_comps);
  assert(phasesTM.size() == n_phases);
  getPhasesTotalMoles(phasesTM);
  const double *dd=m_phaseCompositions;
  double *dr=&(phasesC(0,0));

  for (unsigned i=0;i<n_phases;i++)
  {    
    for (unsigned j=0;j<n_comps;j++)
    {
      *(dr++)=*(dd++)/phasesTM(i);
    }
  }
}



double FlashData::getTotalMoles() const
{
  assert(m_phaseCompositions);
  double acum=0.0;
  const double *dd=m_phaseCompositions;
  const unsigned nElems=n_phases*n_comps;
  for (unsigned i=0;i<nElems;i++)
  {
    acum+=*(dd++);
  }
  return acum;
}


void FlashData::multiply(VecDouble &B,const VecDouble &X)  const
{
  assert(m_phaseCompositions);
  assert(X.size() == n_comps);
  assert(B.size() == n_phases);
  double acum;
  const double *dd=m_phaseCompositions;
  for (unsigned i=0;i<n_phases;i++)
  {
    acum=0;
    for (unsigned j=0;j<n_comps;j++)
      {
        acum+=*(dd++)*X(j);
      }
    B(i)=acum;
  }
}




void FlashData::getMixtureComposition(VecDouble &vComp, double &nT) 
{
  assert(vComp.size() == n_comps);
  const double *dd = m_phaseCompositions;
  for (unsigned j=0;j<n_comps;j++)
    vComp(j)=*(dd++);
  for (unsigned i=1;i<n_phases;i++)
  {
    for (unsigned j=0;j<n_comps;j++)
      vComp(j)+=*(dd++);
  }
  nT=0.0;
  for (unsigned j=0;j<n_comps;j++)
    nT+=vComp(j);
  for (unsigned j=0;j<n_comps;j++)
    vComp(j)/=nT;
      
}


const double* FlashData::getData() const
{
  assert(m_phaseCompositions);
  return m_phaseCompositions;
}


void FlashData::setData(double *dd) 
{
  if (!m_Del)
    m_phaseCompositions=dd;
  else
  {
    m_Del=false;
    if (m_phaseCompositions)
      delete [] m_phaseCompositions;
    m_phaseCompositions=dd;
  }
}



void FlashData::zeroEntries() 
{
  assert(m_phaseCompositions);
  double *dd = m_phaseCompositions;
  unsigned size=n_phases*n_comps;
  for (unsigned i=0;i<size;i++)
    *dd++=0.0;
}



void FlashData::print(std::ostream &out) 
{
  assert(m_phaseCompositions);
  for (unsigned i=0;i<n_phases;i++)
  {
    out << "Phase " << i << ": ";
    for (unsigned j=0;j<n_comps;j++)
      out << getMoles(i,j) << "\t";
    out << std::endl;
  }
  
}

void FlashData::getTotalComponentsMoles(VecDouble &totalComponentsMoles) const
{
  assert(totalComponentsMoles.size() == n_comps);
  assert(m_phaseCompositions);
  double *dd=m_phaseCompositions;
  for (unsigned j=0;j<n_comps;j++)
    totalComponentsMoles(j)=*dd++;

  for (unsigned i=1;i<n_phases;i++)
    for (unsigned j=0;j<n_comps;j++)
      totalComponentsMoles(j)+=*dd++;
}




void FlashData::getPhasesDensities(VecDouble &vDensities,const VecDouble &componentsMolarMass,const VecDouble &phasesVol) 
{
  assert(vDensities.size() == getNPhases());
  assert(componentsMolarMass.size() == getNComponents());
  assert(phasesVol.size() == getNPhases());

  multiply(vDensities,componentsMolarMass);
  NumericMethods::vectorDivideEntriesAvoidingNAN(vDensities,phasesVol);
  
}

void FlashData::setData(FlashData &data) 
{
  assert(data.m_phaseCompositions != NULL);
  assert(!m_Del);
  m_phaseCompositions=data.m_phaseCompositions;
}



void FlashData::deepCopy (const FlashData &data) 
{
  assert(!m_Del);  //Flash Data must not be the owner of its data
  assert(n_phases==data.n_phases);
  assert(n_comps==data.n_comps);
  m_phaseCompositions=new double[n_phases*n_comps];
  m_Del=true;
  memcpy(m_phaseCompositions,data.m_phaseCompositions,n_phases*n_comps*sizeof(double));
}










void FlashData::operator = (const FlashData &data) 
{
  assert(m_phaseCompositions != NULL);
  assert(data.m_phaseCompositions != NULL);
  assert(n_phases == data.n_phases);
  assert(n_comps == data.n_comps);
  memcpy(m_phaseCompositions,data.m_phaseCompositions,n_phases*n_comps*sizeof(double));
}

 FlashData::FlashData(const FlashData &data) 
 {
   assert(data.m_phaseCompositions != NULL);
   n_phases=data.n_phases;
   n_comps=data.n_comps;
   m_phaseCompositions=NULL;
   m_Del = false;
   allocateOwnMemory();
   memcpy(m_phaseCompositions,data.m_phaseCompositions,n_phases*n_comps*sizeof(double));
}

---