research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace DATA_PTR macro with calls to data()

Browse source
This commit is contained in:
Ray Speth 2015-10-17 15:17:57 -04:00
parent 8b16eb489f
commit 0647823ada
60 changed files with 360 additions and 391 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
include/cantera/base/ct_defs.h
View file

@ -32,11 +32,6 @@
namespace Cantera
{
//! Creates a pointer to the start of the raw data for a vector
#ifndef DATA_PTR
#define DATA_PTR(vec) &vec[0]
#endif
using std::shared_ptr;
using std::make_shared;

2
include/cantera/numerics/ResidEval.h
View file

@ -101,7 +101,7 @@ public:
for (int i = 0; i < nn; i++) {
ydot[i] = (y[i] - yold[i]) / deltaT;
}
return eval(t, y, DATA_PTR(ydot), r);
return eval(t, y, ydot.data(), r);
}
//! Fill in the initial conditions

8
include/cantera/oneD/Sim1D.h
View file

@ -100,7 +100,7 @@ public:
void showSolution();
const doublereal* solution() {
return DATA_PTR(m_x);
return m_x.data();
}
void setTimeStep(doublereal stepsize, size_t n, integer* tsteps);
@ -108,7 +108,7 @@ public:
void solve(int loglevel = 0, bool refine_grid = true);
void eval(doublereal rdt=-1.0, int count = 1) {
OneDim::eval(npos, DATA_PTR(m_x), DATA_PTR(m_xnew), rdt, count);
OneDim::eval(npos, m_x.data(), m_xnew.data(), rdt, count);
}
/// Refine the grid in all domains.
@ -140,11 +140,11 @@ public:
void getInitialSoln();
void setSolution(const doublereal* soln) {
std::copy(soln, soln + m_x.size(), DATA_PTR(m_x));
std::copy(soln, soln + m_x.size(), m_x.data());
}
const doublereal* solution() const {
return DATA_PTR(m_x);
return m_x.data();
}
doublereal jacobian(int i, int j);

2
include/cantera/zeroD/ReactorBase.h
View file

@ -196,7 +196,7 @@ public:
//! Return the vector of species mass fractions.
const doublereal* massFractions() const {
return DATA_PTR(m_state) + 2;
return m_state.data() + 2;
}
//! Return the mass fraction of the *k*-th species.

2
samples/cxx/bvp/BoundaryValueProblem.h
View file

@ -74,7 +74,7 @@ public:
for (iz = 0; iz < np; iz++) {
z[iz] = zmin + iz*(zmax - zmin)/(np-1);
}
setupGrid(np, DATA_PTR(z));
setupGrid(np, z.data());
resize(nv, np);
}

6
samples/cxx/flamespeed/flamespeed.cpp
View file

@ -43,7 +43,7 @@ int flamespeed(double phi)
}
}
gas.setState_TPX(temp,pressure,DATA_PTR(x));
gas.setState_TPX(temp,pressure,x.data());
doublereal rho_in=gas.density();
vector_fp yin(nsp);
@ -95,7 +95,7 @@ int flamespeed(double phi)
Inlet1D inlet;
inlet.setMoleFractions(DATA_PTR(x));
inlet.setMoleFractions(x.data());
doublereal mdot=uin*rho_in;
inlet.setMdot(mdot);
inlet.setTemperature(temp);
@ -145,7 +145,7 @@ int flamespeed(double phi)
flame.setInitialGuess(gas.speciesName(i),locs,value);
}
inlet.setMoleFractions(DATA_PTR(x));
inlet.setMoleFractions(x.data());
inlet.setMdot(mdot);
inlet.setTemperature(temp);

2
src/equil/BasisOptimize.cpp
View file

@ -117,7 +117,7 @@ size_t BasisOptimize(int* usedZeroedSpecies, bool doFormRxn, MultiPhase* mphase,
* Create an array of mole numbers
*/
vector_fp molNum(nspecies,0.0);
mphase->getMoles(DATA_PTR(molNum));
mphase->getMoles(molNum.data());
/*
* Other workspace

44
src/equil/ChemEquil.cpp
View file

@ -152,14 +152,14 @@ void ChemEquil::setToEquilState(thermo_t& s,
// Call the phase-specific method to set the phase to the
// equilibrium state with the specified species chemical
// potentials.
s.setToEquilState(DATA_PTR(m_mu_RT));
s.setToEquilState(m_mu_RT.data());
update(s);
}
void ChemEquil::update(const thermo_t& s)
{
// get the mole fractions, temperature, and density
s.getMoleFractions(DATA_PTR(m_molefractions));
s.getMoleFractions(m_molefractions.data());
m_temp = s.temperature();
m_dens = s.density();
@ -238,12 +238,12 @@ int ChemEquil::estimateElementPotentials(thermo_t& s, vector_fp& lambda_RT,
vector_fp mu_RT(m_kk, 0.0);
vector_fp xMF_est(m_kk, 0.0);
s.getMoleFractions(DATA_PTR(xMF_est));
s.getMoleFractions(xMF_est.data());
for (size_t n = 0; n < s.nSpecies(); n++) {
xMF_est[n] = std::max(xMF_est[n], 1e-20);
}
s.setMoleFractions(DATA_PTR(xMF_est));
s.getMoleFractions(DATA_PTR(xMF_est));
s.setMoleFractions(xMF_est.data());
s.getMoleFractions(xMF_est.data());
MultiPhase mp;
mp.addPhase(&s, 1.0);
@ -259,13 +259,13 @@ int ChemEquil::estimateElementPotentials(thermo_t& s, vector_fp& lambda_RT,
m_component[m] = k;
xMF_est[k] = std::max(xMF_est[k], 1e-8);
}
s.setMoleFractions(DATA_PTR(xMF_est));
s.getMoleFractions(DATA_PTR(xMF_est));
s.setMoleFractions(xMF_est.data());
s.getMoleFractions(xMF_est.data());
ElemRearrange(m_nComponents, elMolesGoal, &mp,
m_orderVectorSpecies, m_orderVectorElements);
s.getChemPotentials(DATA_PTR(mu_RT));
s.getChemPotentials(mu_RT.data());
doublereal rrt = 1.0/(GasConstant* s.temperature());
scale(mu_RT.begin(), mu_RT.end(), mu_RT.begin(), rrt);
@ -292,7 +292,7 @@ int ChemEquil::estimateElementPotentials(thermo_t& s, vector_fp& lambda_RT,
b[m] = mu_RT[m_component[m]];
}
int info = solve(aa, DATA_PTR(b));
int info = solve(aa, b.data());
if (info) {
info = -2;
}
@ -449,7 +449,7 @@ int ChemEquil::equilibrate(thermo_t& s, const char* XYstr,
for (size_t k = 0; k < m_kk; k++) {
xmm[k] = s.moleFraction(k) + 1.0E-32;
}
s.setMoleFractions(DATA_PTR(xmm));
s.setMoleFractions(xmm.data());
/*
* Update the internally stored values of m_temp,
@ -540,7 +540,7 @@ int ChemEquil::equilibrate(thermo_t& s, const char* XYstr,
* itself. Or else, create our own estimate.
*/
if (useThermoPhaseElementPotentials) {
bool haveEm = s.getElementPotentials(DATA_PTR(x));
bool haveEm = s.getElementPotentials(x.data());
if (haveEm) {
if (s.temperature() < 100.) {
writelog("we are here {:g}\n", s.temperature());
@ -709,7 +709,7 @@ int ChemEquil::equilibrate(thermo_t& s, const char* XYstr,
* Solve the system
*/
try {
info = solve(jac, DATA_PTR(res_trial));
info = solve(jac, res_trial.data());
} catch (CanteraError& err) {
err.save();
s.restoreState(state);
@ -912,9 +912,9 @@ double ChemEquil::calcEmoles(thermo_t& s, vector_fp& x, const double& n_t,
* previous solution state.
*/
vector_fp actCoeff(m_kk, 1.0);
s.setMoleFractions(DATA_PTR(Xmol_i_calc));
s.setMoleFractions(Xmol_i_calc.data());
s.setPressure(pressureConst);
s.getActivityCoefficients(DATA_PTR(actCoeff));
s.getActivityCoefficients(actCoeff.data());
for (size_t k = 0; k < m_kk; k++) {
tmp = - (m_muSS_RT[k] + log(actCoeff[k]));
@ -961,7 +961,7 @@ int ChemEquil::estimateEP_Brinkley(thermo_t& s, vector_fp& x,
vector_fp Xmol_i_calc(m_kk,0.0);
double beta = 1.0;
s.getMoleFractions(DATA_PTR(n_i));
s.getMoleFractions(n_i.data());
double pressureConst = s.pressure();
copy(n_i.begin(), n_i.end(), Xmol_i_calc.begin());
@ -974,7 +974,7 @@ int ChemEquil::estimateEP_Brinkley(thermo_t& s, vector_fp& x,
* at their standard states of solution at the current T and P
* of the solution.
*/
s.getGibbs_RT(DATA_PTR(m_muSS_RT));
s.getGibbs_RT(m_muSS_RT.data());
vector_fp eMolesCalc(m_mm, 0.0);
vector_fp eMolesFix(m_mm, 0.0);
@ -997,9 +997,9 @@ int ChemEquil::estimateEP_Brinkley(thermo_t& s, vector_fp& x,
double n_t = 0.0;
double sum2 = 0.0;
double nAtomsMax = 1.0;
s.setMoleFractions(DATA_PTR(Xmol_i_calc));
s.setMoleFractions(Xmol_i_calc.data());
s.setPressure(pressureConst);
s.getActivityCoefficients(DATA_PTR(actCoeff));
s.getActivityCoefficients(actCoeff.data());
for (k = 0; k < m_kk; k++) {
tmp = - (m_muSS_RT[k] + log(actCoeff[k]));
sum2 = 0.0;
@ -1388,7 +1388,7 @@ int ChemEquil::estimateEP_Brinkley(thermo_t& s, vector_fp& x,
}
try {
solve(a1, DATA_PTR(resid));
solve(a1, resid.data());
} catch (CanteraError& err) {
err.save();
if (DEBUG_MODE_ENABLED) {
@ -1460,7 +1460,7 @@ void ChemEquil::adjustEloc(thermo_t& s, vector_fp& elMolesGoal)
if (fabs(elMolesGoal[m_eloc]) > 1.0E-20) {
return;
}
s.getMoleFractions(DATA_PTR(m_molefractions));
s.getMoleFractions(m_molefractions.data());
size_t k;
size_t maxPosEloc = npos;
size_t maxNegEloc = npos;
@ -1520,8 +1520,8 @@ void ChemEquil::adjustEloc(thermo_t& s, vector_fp& elMolesGoal)
}
}
s.setMoleFractions(DATA_PTR(m_molefractions));
s.getMoleFractions(DATA_PTR(m_molefractions));
s.setMoleFractions(m_molefractions.data());
s.getMoleFractions(m_molefractions.data());
}
} // namespace

17
src/equil/MultiPhase.cpp
View file

@ -223,7 +223,7 @@ ThermoPhase& MultiPhase::phase(size_t n)
init();
}
m_phase[n]->setTemperature(m_temp);
m_phase[n]->setMoleFractions_NoNorm(DATA_PTR(m_moleFractions) + m_spstart[n]);
m_phase[n]->setMoleFractions_NoNorm(&m_moleFractions[m_spstart[n]]);
m_phase[n]->setPressure(m_press);
return *m_phase[n];
}
@ -425,7 +425,7 @@ void MultiPhase::setMolesByName(const compositionMap& xMap)
for (size_t k = 0; k < kk; k++) {
moles[k] = std::max(getValue(xMap, speciesName(k), 0.0), 0.0);
}
setMoles(DATA_PTR(moles));
setMoles(moles.data());
}
void MultiPhase::setMolesByName(const std::string& x)
@ -473,9 +473,9 @@ void MultiPhase::setMoles(const doublereal* n)
if (nsp > 1) {
if (phasemoles > 0.0) {
p->setState_TPX(m_temp, m_press, n + loc);
p->getMoleFractions(DATA_PTR(m_moleFractions) + loc);
p->getMoleFractions(&m_moleFractions[loc]);
} else {
p->getMoleFractions(DATA_PTR(m_moleFractions) + loc);
p->getMoleFractions(&m_moleFractions[loc]);
}
} else {
m_moleFractions[loc] = 1.0;
@ -487,10 +487,10 @@ void MultiPhase::setMoles(const doublereal* n)
void MultiPhase::addSpeciesMoles(const int indexS, const doublereal addedMoles)
{
vector_fp tmpMoles(m_nsp, 0.0);
getMoles(DATA_PTR(tmpMoles));
getMoles(tmpMoles.data());
tmpMoles[indexS] += addedMoles;
tmpMoles[indexS] = std::max(tmpMoles[indexS], 0.0);
setMoles(DATA_PTR(tmpMoles));
setMoles(tmpMoles.data());
}
void MultiPhase::setState_TP(const doublereal T, const doublereal Pres)
@ -912,7 +912,7 @@ void MultiPhase::uploadMoleFractionsFromPhases()
size_t ip, loc = 0;
for (ip = 0; ip < m_np; ip++) {
ThermoPhase* p = m_phase[ip];
p->getMoleFractions(DATA_PTR(m_moleFractions) + loc);
p->getMoleFractions(&m_moleFractions[loc]);
loc += p->nSpecies();
}
calcElemAbundances();
@ -923,9 +923,8 @@ void MultiPhase::updatePhases() const
size_t p, nsp, loc = 0;
for (p = 0; p < m_np; p++) {
nsp = m_phase[p]->nSpecies();
const doublereal* x = DATA_PTR(m_moleFractions) + loc;
m_phase[p]->setState_TPX(m_temp, m_press, &m_moleFractions[loc]);
loc += nsp;
m_phase[p]->setState_TPX(m_temp, m_press, x);
m_temp_OK[p] = true;
if (m_temp < m_phase[p]->minTemp() || m_temp > m_phase[p]->maxTemp()) {
m_temp_OK[p] = false;

30
src/equil/MultiPhaseEquil.cpp
View file

@ -144,7 +144,7 @@ MultiPhaseEquil::MultiPhaseEquil(MultiPhase* mix, bool start, int loglevel) : m_
// species has precisely zero moles.
vector_fp dxi(nFree(), 1.0e-20);
if (!dxi.empty()) {
multiply(m_N, DATA_PTR(dxi), DATA_PTR(m_work));
multiply(m_N, dxi.data(), m_work.data());
unsort(m_work);
}
@ -193,7 +193,7 @@ void MultiPhaseEquil::updateMixMoles()
for (k = 0; k < m_nsp; k++) {
m_work3[m_species[k]] = m_moles[k];
}
m_mix->setMoles(DATA_PTR(m_work3));
m_mix->setMoles(m_work3.data());
}
void MultiPhaseEquil::finish()
@ -203,14 +203,14 @@ void MultiPhaseEquil::finish()
for (k = 0; k < m_nsp; k++) {
m_work3[m_species[k]] = (m_moles[k] > 0.0 ? m_moles[k] : 0.0);
}
m_mix->setMoles(DATA_PTR(m_work3));
m_mix->setMoles(m_work3.data());
}
int MultiPhaseEquil::setInitialMoles(int loglevel)
{
size_t ik, j;
double not_mu = 1.0e12;
m_mix->getValidChemPotentials(not_mu, DATA_PTR(m_mu), true);
m_mix->getValidChemPotentials(not_mu, m_mu.data(), true);
doublereal dg_rt;
int idir;
double nu;
@ -460,7 +460,7 @@ doublereal MultiPhaseEquil::stepComposition(int loglevel)
// compute the mole fraction changes.
if (nFree()) {
multiply(m_N, DATA_PTR(m_dxi), DATA_PTR(m_work));
multiply(m_N, m_dxi.data(), m_work.data());
}
// change to sequential form
@ -520,7 +520,7 @@ doublereal MultiPhaseEquil::stepComposition(int loglevel)
// current direction. If it is positive, then we have overshot
// the minimum. In this case, interpolate back.
doublereal not_mu = 1.0e12;
m_mix->getValidChemPotentials(not_mu, DATA_PTR(m_mu));
m_mix->getValidChemPotentials(not_mu, m_mu.data());
doublereal grad1 = 0.0;
for (k = 0; k < m_nsp; k++) {
grad1 += m_work[k] * m_mu[m_species[k]];
@ -546,7 +546,7 @@ doublereal MultiPhaseEquil::computeReactionSteps(vector_fp& dxi)
dxi.resize(nFree());
computeN();
doublereal not_mu = 1.0e12;
m_mix->getValidChemPotentials(not_mu, DATA_PTR(m_mu));
m_mix->getValidChemPotentials(not_mu, m_mu.data());
for (j = 0; j < nFree(); j++) {
// get stoichiometric vector
@ -725,7 +725,7 @@ void MultiPhaseEquil::reportCSV(const std::string& reportFile)
nSpecies = tref.nSpecies();
VolPM.resize(nSpecies, 0.0);
tref.getMoleFractions(&mf[istart]);
tref.getPartialMolarVolumes(DATA_PTR(VolPM));
tref.getPartialMolarVolumes(VolPM.data());
double TMolesPhase = phaseMoles(iphase);
double VolPhaseVolumes = 0.0;
@ -756,11 +756,11 @@ void MultiPhaseEquil::reportCSV(const std::string& reportFile)
VolPM.resize(nSpecies, 0.0);
molalities.resize(nSpecies, 0.0);
int actConvention = tp->activityConvention();
tp->getActivities(DATA_PTR(activity));
tp->getActivityCoefficients(DATA_PTR(ac));
tp->getStandardChemPotentials(DATA_PTR(mu0));
tp->getPartialMolarVolumes(DATA_PTR(VolPM));
tp->getChemPotentials(DATA_PTR(mu));
tp->getActivities(activity.data());
tp->getActivityCoefficients(ac.data());
tp->getStandardChemPotentials(mu0.data());
tp->getPartialMolarVolumes(VolPM.data());
tp->getChemPotentials(mu.data());
double VolPhaseVolumes = 0.0;
for (k = 0; k < nSpecies; k++) {
VolPhaseVolumes += VolPM[k] * mf[istart + k];
@ -769,8 +769,8 @@ void MultiPhaseEquil::reportCSV(const std::string& reportFile)
vol += VolPhaseVolumes;
if (actConvention == 1) {
MolalityVPSSTP* mTP = static_cast<MolalityVPSSTP*>(tp);
mTP->getMolalities(DATA_PTR(molalities));
tp->getChemPotentials(DATA_PTR(mu));
mTP->getMolalities(molalities.data());
tp->getChemPotentials(mu.data());
if (iphase == 0) {
fprintf(FP," Name, Phase, PhaseMoles, Mole_Fract, "

2
src/equil/vcs_MultiPhaseEquil.cpp
View file

@ -1306,7 +1306,7 @@ int vcs_MultiPhaseEquil::determine_PhaseStability(int iph, double& funcStab, int
* states.
*/
m_mix->uploadMoleFractionsFromPhases();
m_mix->getChemPotentials(DATA_PTR(m_vprob.m_gibbsSpecies));
m_mix->getChemPotentials(m_vprob.m_gibbsSpecies.data());
double te = tickTock.secondsWC();
if (printLvl > 0) {

2
src/equil/vcs_phaseStability.cpp
View file

@ -387,7 +387,7 @@ int VCS_SOLVE::vcs_popPhaseRxnStepSizes(const size_t iphasePop)
doublereal deltaMolNumPhase = tPhaseMoles;
doublereal damp = 1.0;
m_deltaGRxn_tmp = m_molNumSpecies_old;
double* molNumSpecies_tmp = DATA_PTR(m_deltaGRxn_tmp);
double* molNumSpecies_tmp = m_deltaGRxn_tmp.data();
for (size_t k = 0; k < Vphase->nSpecies(); k++) {
kspec = Vphase->spGlobalIndexVCS(k);

4
src/equil/vcs_setMolesLinProg.cpp
View file

@ -38,10 +38,6 @@ int VCS_SOLVE::vcs_setMolesLinProg()
plogf(" --- call setInitialMoles\n");
}
// m_mu are standard state chemical potentials
// Boolean on the end specifies standard chem potentials
// m_mix->getValidChemPotentials(not_mu, DATA_PTR(m_mu), true);
// -> This is already done coming into the routine.
double dg_rt;
int idir;
double nu;

8
src/kinetics/ImplicitSurfChem.cpp
View file

@ -146,7 +146,7 @@ void ImplicitSurfChem::eval(doublereal time, doublereal* y,
size_t loc, kstart;
for (size_t n = 0; n < m_nsurf; n++) {
rs0 = 1.0/m_surf[n]->siteDensity();
m_vecKinPtrs[n]->getNetProductionRates(DATA_PTR(m_work));
m_vecKinPtrs[n]->getNetProductionRates(m_work.data());
kstart = m_vecKinPtrs[n]->kineticsSpeciesIndex(0,m_surfindex[n]);
sum = 0.0;
loc = 0;
@ -194,7 +194,7 @@ void ImplicitSurfChem::solvePseudoSteadyStateProblem(int ifuncOverride,
* 1) concentrations of all species in all phases, m_concSpecies[]
* 2) Temperature and pressure
*/
getConcSpecies(DATA_PTR(m_concSpecies));
getConcSpecies(m_concSpecies.data());
InterfaceKinetics* ik = m_vecKinPtrs[0];
ThermoPhase& tp = ik->thermo(0);
doublereal TKelvin = tp.temperature();
@ -225,7 +225,7 @@ void ImplicitSurfChem::solvePseudoSteadyStateProblem(int ifuncOverride,
}
}
if (rset) {
setConcSpecies(DATA_PTR(m_concSpecies));
setConcSpecies(m_concSpecies.data());
}
m_surfSolver->m_ioflag = m_ioFlag;
@ -238,7 +238,7 @@ void ImplicitSurfChem::solvePseudoSteadyStateProblem(int ifuncOverride,
if (retn != 1) {
// reset the concentrations
copy(m_concSpeciesSave.begin(), m_concSpeciesSave.end(), m_concSpecies.begin());
setConcSpecies(DATA_PTR(m_concSpeciesSave));
setConcSpecies(m_concSpeciesSave.data());
ifunc = SFLUX_INITIALIZE;
retn = m_surfSolver->solveSurfProb(ifunc, time_scale, TKelvin, PGas,
reltol, atol);

4
src/kinetics/ReactionPath.cpp
View file

@ -747,8 +747,8 @@ int ReactionPathBuilder::build(Kinetics& s, const string& element,
return -1;
}
s.getFwdRatesOfProgress(DATA_PTR(m_ropf));
s.getRevRatesOfProgress(DATA_PTR(m_ropr));
s.getFwdRatesOfProgress(m_ropf.data());
s.getRevRatesOfProgress(m_ropr.data());
// species explicitly included or excluded
vector<string>& in_nodes = r.included();

46
src/kinetics/solveSP.cpp
View file

@ -160,7 +160,7 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
size_t loc = 0;
for (size_t n = 0; n < m_numSurfPhases; n++) {
SurfPhase* sf_ptr = m_ptrsSurfPhase[n];
sf_ptr->getConcentrations(DATA_PTR(m_numEqn1));
sf_ptr->getConcentrations(m_numEqn1.data());
size_t nsp = m_nSpeciesSurfPhase[n];
for (size_t k = 0; k <nsp; k++) {
m_CSolnSP[loc] = m_numEqn1[k];
@ -171,7 +171,7 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
std::copy(m_CSolnSP.begin(), m_CSolnSP.end(), m_CSolnSPInit.begin());
// Calculate the largest species in each phase
evalSurfLarge(DATA_PTR(m_CSolnSP));
evalSurfLarge(m_CSolnSP.data());
if (m_ioflag) {
print_header(m_ioflag, ifunc, time_scale, true, reltol, abstol);
@ -201,7 +201,7 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
* 5 iterations.
*/
if (iter%5 == 4) {
evalSurfLarge(DATA_PTR(m_CSolnSP));
evalSurfLarge(m_CSolnSP.data());
}
/*
@ -213,8 +213,8 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
if (damp < 1.0) {
label_factor = 1.0;
}
tmp = calc_t(DATA_PTR(m_netProductionRatesSave),
DATA_PTR(m_XMolKinSpecies),
tmp = calc_t(m_netProductionRatesSave.data(),
m_XMolKinSpecies.data(),
&label_t, &label_t_old, &label_factor, m_ioflag);
if (iter < 10) {
inv_t = tmp;
@ -244,23 +244,22 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
* Call the routine to numerically evaluation the Jacobian
* and residual for the current iteration.
*/
resjac_eval(m_Jac, DATA_PTR(m_resid), DATA_PTR(m_CSolnSP),
DATA_PTR(m_CSolnSPOld), do_time, deltaT);
resjac_eval(m_Jac, m_resid.data(), m_CSolnSP.data(),
m_CSolnSPOld.data(), do_time, deltaT);
/*
* Calculate the weights. Make sure the calculation is carried
* out on the first iteration.
*/
if (iter%4 == 1) {
calcWeights(DATA_PTR(m_wtSpecies), DATA_PTR(m_wtResid),
m_Jac, DATA_PTR(m_CSolnSP), abstol, reltol);
calcWeights(m_wtSpecies.data(), m_wtResid.data(),
m_Jac, m_CSolnSP.data(), abstol, reltol);
}
/*
* Find the weighted norm of the residual
*/
resid_norm = calcWeightedNorm(DATA_PTR(m_wtResid),
DATA_PTR(m_resid), m_neq);
resid_norm = calcWeightedNorm(m_wtResid.data(), m_resid.data(), m_neq);
/*
* Solve Linear system. The solution is in resid[]
@ -305,15 +304,15 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
* between 0 and 1, and not allow too large a change (factor of 2)
* in any unknown.
*/
damp = calc_damping(DATA_PTR(m_CSolnSP), DATA_PTR(m_resid), m_neq, &label_d);
damp = calc_damping(m_CSolnSP.data(), m_resid.data(), m_neq, &label_d);
/*
* Calculate the weighted norm of the update vector
* Here, resid is the delta of the solution, in concentration
* units.
*/
update_norm = calcWeightedNorm(DATA_PTR(m_wtSpecies),
DATA_PTR(m_resid), m_neq);
update_norm = calcWeightedNorm(m_wtSpecies.data(),
m_resid.data(), m_neq);
/*
* Update the solution vector and real time
* Crop the concentrations to zero.
@ -324,7 +323,7 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
for (size_t irow = 0; irow < m_neq; irow++) {
m_CSolnSP[irow] = std::max(0.0, m_CSolnSP[irow]);
}
updateState(DATA_PTR(m_CSolnSP));
updateState(m_CSolnSP.data());
if (do_time) {
t_real += damp/inv_t;
@ -368,10 +367,9 @@ int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin,
* no matter how bad
*/
if (m_ioflag) {
fun_eval(DATA_PTR(m_resid), DATA_PTR(m_CSolnSP), DATA_PTR(m_CSolnSPOld),
fun_eval(m_resid.data(), m_CSolnSP.data(), m_CSolnSPOld.data(),
false, deltaT);
resid_norm = calcWeightedNorm(DATA_PTR(m_wtResid),
DATA_PTR(m_resid), m_neq);
resid_norm = calcWeightedNorm(m_wtResid.data(), m_resid.data(), m_neq);
printIteration(m_ioflag, damp, label_d, label_t, inv_t, t_real, iter,
update_norm, resid_norm, do_time, true);
}
@ -459,7 +457,7 @@ void solveSP::fun_eval(doublereal* resid, const doublereal* CSoln,
size_t surfIndex = kinPtr->surfacePhaseIndex();
kstart = kinPtr->kineticsSpeciesIndex(0, surfIndex);
kins = kindexSP;
kinPtr->getNetProductionRates(DATA_PTR(m_netProductionRatesSave));
kinPtr->getNetProductionRates(m_netProductionRatesSave.data());
for (k = 0; k < nsp; k++, kindexSP++) {
resid[kindexSP] =
(CSoln[kindexSP] - CSolnOld[kindexSP]) / deltaT
@ -481,7 +479,7 @@ void solveSP::fun_eval(doublereal* resid, const doublereal* CSoln,
size_t surfIndex = kinPtr->surfacePhaseIndex();
kstart = kinPtr->kineticsSpeciesIndex(0, surfIndex);
kins = kindexSP;
kinPtr->getNetProductionRates(DATA_PTR(m_netProductionRatesSave));
kinPtr->getNetProductionRates(m_netProductionRatesSave.data());
for (k = 0; k < nsp; k++, kindexSP++) {
resid[kindexSP] = - m_netProductionRatesSave[kstart + k];
}
@ -497,7 +495,7 @@ void solveSP::fun_eval(doublereal* resid, const doublereal* CSoln,
if (m_bulkFunc == BULK_DEPOSITION) {
kindexSP = m_numTotSurfSpecies;
for (isp = 0; isp < m_numBulkPhasesSS; isp++) {
doublereal* XBlk = DATA_PTR(m_numEqn1);
doublereal* XBlk = m_numEqn1.data();
nsp = m_nSpeciesSurfPhase[isp];
size_t surfPhaseIndex = m_indexKinObjSurfPhase[isp];
InterfaceKinetics* m_kin = m_objects[isp];
@ -562,7 +560,7 @@ void solveSP::resjac_eval(SquareMatrix& jac,
cSave = CSoln[kColIndex];
dc = std::max(1.0E-10 * sd, fabs(cSave) * 1.0E-7);
CSoln[kColIndex] += dc;
fun_eval(DATA_PTR(m_numEqn2), CSoln, CSolnOld, do_time, deltaT);
fun_eval(m_numEqn2.data(), CSoln, CSolnOld, do_time, deltaT);
for (i = 0; i < m_neq; i++) {
jac(i, kColIndex) = (m_numEqn2[i] - resid[i])/dc;
}
@ -579,7 +577,7 @@ void solveSP::resjac_eval(SquareMatrix& jac,
cSave = CSoln[kColIndex];
dc = std::max(1.0E-10 * sd, fabs(cSave) * 1.0E-7);
CSoln[kColIndex] += dc;
fun_eval(DATA_PTR(m_numEqn2), CSoln, CSolnOld, do_time, deltaT);
fun_eval(m_numEqn2.data(), CSoln, CSolnOld, do_time, deltaT);
for (i = 0; i < m_neq; i++) {
jac(i, kColIndex) = (m_numEqn2[i] - resid[i])/dc;
}
@ -732,7 +730,7 @@ doublereal solveSP::calc_t(doublereal netProdRateSolnSP[],
size_t surfIndex = m_kin->surfacePhaseIndex();
kstart = m_kin->kineticsSpeciesIndex(0, surfIndex);
ThermoPhase& THref = m_kin->thermo(surfIndex);
m_kin->getNetProductionRates(DATA_PTR(m_numEqn1));
m_kin->getNetProductionRates(m_numEqn1.data());
sden = THref.molarDensity();
for (k = 0; k < nsp; k++, kindexSP++) {
size_t kspindex = kstart + k;

10
src/numerics/BandMatrix.cpp
View file

@ -235,7 +235,7 @@ int BandMatrix::factor()
int info=0;
copy(data.begin(), data.end(), ludata.begin());
ct_dgbtrf(nRows(), nColumns(), nSubDiagonals(), nSuperDiagonals(),
DATA_PTR(ludata), ldim(), DATA_PTR(ipiv()), info);
ludata.data(), ldim(), ipiv().data(), info);
// if info = 0, LU decomp succeeded.
if (info == 0) {
@ -266,8 +266,8 @@ int BandMatrix::solve(doublereal* b, size_t nrhs, size_t ldb)
}
if (info == 0) {
ct_dgbtrs(ctlapack::NoTranspose, nColumns(), nSubDiagonals(),
nSuperDiagonals(), nrhs, DATA_PTR(ludata), ldim(),
DATA_PTR(ipiv()), b, ldb, info);
nSuperDiagonals(), nrhs, ludata.data(), ldim(),
ipiv().data(), b, ldb, info);
}
// error handling
@ -331,8 +331,8 @@ doublereal BandMatrix::rcond(doublereal a1norm)
size_t ldab = (2 *m_kl + m_ku + 1);
int rinfo = 0;
rcond = ct_dgbcon('1', m_n, m_kl, m_ku, DATA_PTR(ludata), ldab, DATA_PTR(m_ipiv), a1norm, DATA_PTR(work_),
DATA_PTR(iwork_), rinfo);
rcond = ct_dgbcon('1', m_n, m_kl, m_ku, ludata.data(), ldab, m_ipiv.data(), a1norm, work_.data(),
iwork_.data(), rinfo);
if (rinfo != 0) {
if (printLevel) {
writelogf("BandMatrix::rcond(): DGBCON returned INFO = %d\n", rinfo);

8
src/numerics/CVodeInt.cpp
View file

@ -218,12 +218,12 @@ void CVodeInt::initialize(double t0, FuncEval& func)
m_cvode_mem = CVodeMalloc(m_neq, cvode_rhs, m_t0, m_y, m_method,
m_iter, m_itol, &m_reltol,
m_abstol, m_data, NULL, 1, m_iopt,
DATA_PTR(m_ropt), NULL);
m_ropt.data(), NULL);
} else {
m_cvode_mem = CVodeMalloc(m_neq, cvode_rhs, m_t0, m_y, m_method,
m_iter, m_itol, &m_reltol,
&m_abstols, m_data, NULL, 1, m_iopt,
DATA_PTR(m_ropt), NULL);
m_ropt.data(), NULL);
}
if (!m_cvode_mem) {
@ -261,12 +261,12 @@ void CVodeInt::reinitialize(double t0, FuncEval& func)
result = CVReInit(m_cvode_mem, cvode_rhs, m_t0, m_y, m_method,
m_iter, m_itol, &m_reltol,
m_abstol, m_data, NULL, 1, m_iopt,
DATA_PTR(m_ropt), NULL);
m_ropt.data(), NULL);
} else {
result = CVReInit(m_cvode_mem, cvode_rhs, m_t0, m_y, m_method,
m_iter, m_itol, &m_reltol,
&m_abstols, m_data, NULL, 1, m_iopt,
DATA_PTR(m_ropt), NULL);
m_ropt.data(), NULL);
}
if (result != 0) {

6
src/numerics/CVodesIntegrator.cpp
View file

@ -70,7 +70,7 @@ extern "C" {
if (d->m_pars.size() == 0) {
f->eval(t, ydata, ydotdata, NULL);
} else {
f->eval(t, ydata, ydotdata, DATA_PTR(d->m_pars));
f->eval(t, ydata, ydotdata, d->m_pars.data());
}
} catch (CanteraError& err) {
std::cerr << err.what() << std::endl;
@ -259,7 +259,7 @@ void CVodesIntegrator::sensInit(double t0, FuncEval& func)
}
vector_fp atol(m_np, m_abstolsens);
double rtol = m_reltolsens;
flag = CVodeSensSStolerances(m_cvode_mem, rtol, DATA_PTR(atol));
flag = CVodeSensSStolerances(m_cvode_mem, rtol, atol.data());
}
@ -334,7 +334,7 @@ void CVodesIntegrator::initialize(double t0, FuncEval& func)
}
if (func.nparams() > 0) {
sensInit(t0, func);
flag = CVodeSetSensParams(m_cvode_mem, DATA_PTR(m_fdata->m_pars),
flag = CVodeSetSensParams(m_cvode_mem, m_fdata->m_pars.data(),
NULL, NULL);
}
applyOptions();

20
src/numerics/SquareMatrix.cpp
View file

@ -76,7 +76,7 @@ int SquareMatrix::solve(doublereal* b, size_t nrhs, size_t ldb)
*/
ct_dgetrs(ctlapack::NoTranspose, static_cast<int>(nRows()),
nrhs, &*begin(), static_cast<int>(nRows()),
DATA_PTR(ipiv()), b, ldb, info);
ipiv().data(), b, ldb, info);
if (info != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::solve(): DGETRS returned INFO = %d\n", info);
@ -122,7 +122,7 @@ int SquareMatrix::factor()
integer n = static_cast<int>(nRows());
int info=0;
m_factored = 1;
ct_dgetrf(n, n, &*begin(), static_cast<int>(nRows()), DATA_PTR(ipiv()), info);
ct_dgetrf(n, n, &*begin(), static_cast<int>(nRows()), ipiv().data(), info);
if (info != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::factor(): DGETRS returned INFO = %d\n", info);
@ -145,11 +145,11 @@ int SquareMatrix::factorQR()
tau.resize(m_nrows, 0.0);
work.resize(8 * m_nrows, 0.0);
}
a1norm_ = ct_dlange('1', m_nrows, m_nrows, &*begin(), m_nrows, DATA_PTR(work));
a1norm_ = ct_dlange('1', m_nrows, m_nrows, &*begin(), m_nrows, work.data());
int info = 0;
m_factored = 2;
size_t lwork = work.size();
ct_dgeqrf(m_nrows, m_nrows, &*begin(), m_nrows, DATA_PTR(tau), DATA_PTR(work), lwork, info);
ct_dgeqrf(m_nrows, m_nrows, &*begin(), m_nrows, tau.data(), work.data(), lwork, info);
if (info != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::factorQR(): DGEQRF returned INFO = %d\n", info);
@ -187,8 +187,8 @@ int SquareMatrix::solveQR(doublereal* b)
/*
* Solve the factored system
*/
ct_dormqr(ctlapack::Left, ctlapack::Transpose, m_nrows, 1, m_nrows, &*begin(), m_nrows, DATA_PTR(tau), b, m_nrows,
DATA_PTR(work), lwork, info);
ct_dormqr(ctlapack::Left, ctlapack::Transpose, m_nrows, 1, m_nrows, &*begin(), m_nrows, tau.data(), b, m_nrows,
work.data(), lwork, info);
if (info != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::solveQR(): DORMQR returned INFO = %d\n", info);
@ -230,8 +230,8 @@ doublereal SquareMatrix::rcond(doublereal anorm)
}
int rinfo = 0;
rcond = ct_dgecon('1', m_nrows, &*begin(), m_nrows, anorm, DATA_PTR(work),
DATA_PTR(iwork_), rinfo);
rcond = ct_dgecon('1', m_nrows, &*begin(), m_nrows, anorm, work.data(),
iwork_.data(), rinfo);
if (rinfo != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::rcond(): DGECON returned INFO = %d\n", rinfo);
@ -262,8 +262,8 @@ doublereal SquareMatrix::rcondQR()
}
int rinfo = 0;
rcond = ct_dtrcon(0, ctlapack::UpperTriangular, 0, m_nrows, &*begin(), m_nrows, DATA_PTR(work),
DATA_PTR(iwork_), rinfo);
rcond = ct_dtrcon(0, ctlapack::UpperTriangular, 0, m_nrows, &*begin(), m_nrows, work.data(),
iwork_.data(), rinfo);
if (rinfo != 0) {
if (m_printLevel) {
writelogf("SquareMatrix::rcondQR(): DTRCON returned INFO = %d\n", rinfo);

2
src/oneD/MultiJac.cpp
View file

@ -66,7 +66,7 @@ void MultiJac::eval(doublereal* x0, doublereal* resid0, doublereal rdt)
rdx = 1.0/dx;
// calculate perturbed residual
m_resid->eval(j, x0, DATA_PTR(m_r1), rdt, 0);
m_resid->eval(j, x0, m_r1.data(), rdt, 0);
// compute nth column of Jacobian
for (size_t i = j - 1; i != j+2; i++) {

2
src/oneD/MultiNewton.cpp
View file

@ -328,7 +328,7 @@ int MultiNewton::solve(doublereal* x0, doublereal* x1,
if (forceNewJac) {
r.eval(npos, &m_x[0], &m_stp[0], 0.0, 0);
jac.eval(&m_x[0], &m_stp[0], 0.0);
jac.updateTransient(rdt, DATA_PTR(r.transientMask()));
jac.updateTransient(rdt, r.transientMask().data());
forceNewJac = false;
}

10
src/oneD/OneDim.cpp
View file

@ -192,7 +192,7 @@ int OneDim::solve(doublereal* x, doublereal* xnew, int loglevel)
if (!m_jac_ok) {
eval(npos, x, xnew, 0.0, 0);
m_jac->eval(x, xnew, 0.0);
m_jac->updateTransient(m_rdt, DATA_PTR(m_mask));
m_jac->updateTransient(m_rdt, m_mask.data());
m_jac_ok = true;
}
return m_newt->solve(x, xnew, *this, *m_jac, loglevel);
@ -234,12 +234,12 @@ void OneDim::eval(size_t j, double* x, double* r, doublereal rdt, int count)
// iterate over the bulk domains first
for (const auto& d : m_bulk) {
d->eval(j, x, r, DATA_PTR(m_mask), rdt);
d->eval(j, x, r, m_mask.data(), rdt);
}
// then over the connector domains
for (const auto& d : m_connect) {
d->eval(j, x, r, DATA_PTR(m_mask), rdt);
d->eval(j, x, r, m_mask.data(), rdt);
}
// increment counter and time
@ -268,7 +268,7 @@ void OneDim::initTimeInteg(doublereal dt, doublereal* x)
// if the stepsize has changed, then update the transient
// part of the Jacobian
if (fabs(rdt_old - m_rdt) > Tiny) {
m_jac->updateTransient(m_rdt, DATA_PTR(m_mask));
m_jac->updateTransient(m_rdt, m_mask.data());
}
// iterate over all domains, preparing each one to begin
@ -283,7 +283,7 @@ void OneDim::initTimeInteg(doublereal dt, doublereal* x)
void OneDim::setSteadyMode()
{
m_rdt = 0.0;
m_jac->updateTransient(m_rdt, DATA_PTR(m_mask));
m_jac->updateTransient(m_rdt, m_mask.data());
// iterate over all domains, preparing them for steady-state solution
Domain1D* d = left();

29
src/oneD/Sim1D.cpp
View file

@ -23,7 +23,7 @@ Sim1D::Sim1D(vector<Domain1D*>& domains) :
m_x.resize(size(), 0.0);
m_xnew.resize(size(), 0.0);
for (size_t n = 0; n < m_nd; n++) {
domain(n)._getInitialSoln(DATA_PTR(m_x) + start(n));
domain(n)._getInitialSoln(&m_x[start(n)]);
}
// set some defaults
@ -86,7 +86,7 @@ void Sim1D::setProfile(size_t dom, size_t comp,
void Sim1D::save(const std::string& fname, const std::string& id,
const std::string& desc, int loglevel)
{
OneDim::save(fname, id, desc, DATA_PTR(m_x), loglevel);
OneDim::save(fname, id, desc, m_x.data(), loglevel);
}
void Sim1D::saveResidual(const std::string& fname, const std::string& id,
@ -132,7 +132,7 @@ void Sim1D::restore(const std::string& fname, const std::string& id,
m_x.resize(sz);
m_xnew.resize(sz);
for (size_t m = 0; m < m_nd; m++) {
domain(m).restore(*xd[m], DATA_PTR(m_x) + domain(m).loc(), loglevel);
domain(m).restore(*xd[m], &m_x[domain(m).loc()], loglevel);
}
resize();
finalize();
@ -151,7 +151,7 @@ void Sim1D::showSolution(ostream& s)
{
for (size_t n = 0; n < m_nd; n++) {
if (domain(n).domainType() != cEmptyType) {
domain(n).showSolution_s(s, DATA_PTR(m_x) + start(n));
domain(n).showSolution_s(s, &m_x[start(n)]);
}
}
}
@ -162,7 +162,7 @@ void Sim1D::showSolution()
if (domain(n).domainType() != cEmptyType) {
writelog("\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "+domain(n).id()
+" <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n");
domain(n).showSolution(DATA_PTR(m_x) + start(n));
domain(n).showSolution(&m_x[start(n)]);
}
}
}
@ -170,14 +170,14 @@ void Sim1D::showSolution()
void Sim1D::getInitialSoln()
{
for (size_t n = 0; n < m_nd; n++) {
domain(n)._getInitialSoln(DATA_PTR(m_x) + start(n));
domain(n)._getInitialSoln(&m_x[start(n)]);
}
}
void Sim1D::finalize()
{
for (size_t n = 0; n < m_nd; n++) {
domain(n)._finalize(DATA_PTR(m_x) + start(n));
domain(n)._finalize(&m_x[start(n)]);
}
}
@ -192,7 +192,7 @@ void Sim1D::setTimeStep(doublereal stepsize, size_t n, integer* tsteps)
int Sim1D::newtonSolve(int loglevel)
{
int m = OneDim::solve(DATA_PTR(m_x), DATA_PTR(m_xnew), loglevel);
int m = OneDim::solve(m_x.data(), m_xnew.data(), loglevel);
if (m >= 0) {
copy(m_xnew.begin(), m_xnew.end(), m_x.begin());
return 0;
@ -257,7 +257,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
"After unsuccessful Newton solve");
}
debuglog("Take "+int2str(nsteps)+" timesteps ", loglevel);
dt = timeStep(nsteps, dt, DATA_PTR(m_x), DATA_PTR(m_xnew),
dt = timeStep(nsteps, dt, m_x.data(), m_xnew.data(),
loglevel-1);
if (loglevel > 6) {
save("debug_sim1d.xml", "debug", "After timestepping");
@ -269,7 +269,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
if (loglevel == 1) {
writelog(" {:10.4g} {:10.4g}\n", dt,
log10(ssnorm(DATA_PTR(m_x), DATA_PTR(m_xnew))));
log10(ssnorm(m_x.data(), m_xnew.data())));
}
istep++;
if (istep >= m_steps.size()) {
@ -324,8 +324,7 @@ int Sim1D::refine(int loglevel)
Refiner& r = d.refiner();
// determine where new points are needed
ianalyze = r.analyze(d.grid().size(),
DATA_PTR(d.grid()), DATA_PTR(m_x) + start(n));
ianalyze = r.analyze(d.grid().size(), d.grid().data(), &m_x[start(n)]);
if (ianalyze < 0) {
return ianalyze;
}
@ -382,7 +381,7 @@ int Sim1D::refine(int loglevel)
for (size_t n = 0; n < m_nd; n++) {
Domain1D& d = domain(n);
gridsize = dsize[n];
d.setupGrid(gridsize, DATA_PTR(znew) + gridstart);
d.setupGrid(gridsize, &znew[gridstart]);
gridstart += gridsize;
}
@ -475,7 +474,7 @@ int Sim1D::setFixedTemperature(doublereal t)
for (n = 0; n < m_nd; n++) {
Domain1D& d = domain(n);
gridsize = dsize[n];
d.setupGrid(gridsize, DATA_PTR(znew) + gridstart);
d.setupGrid(gridsize, &znew[gridstart]);
gridstart += gridsize;
}
@ -538,6 +537,6 @@ doublereal Sim1D::jacobian(int i, int j)
void Sim1D::evalSSJacobian()
{
OneDim::evalSSJacobian(DATA_PTR(m_x), DATA_PTR(m_xnew));
OneDim::evalSSJacobian(m_x.data(), m_xnew.data());
}
}

33
src/oneD/StFlow.cpp
View file

@ -87,7 +87,7 @@ StFlow::StFlow(IdealGasPhase* ph, size_t nsp, size_t points) :
for (size_t ng = 0; ng < m_points; ng++) {
gr.push_back(1.0*ng/m_points);
}
setupGrid(m_points, DATA_PTR(gr));
setupGrid(m_points, gr.data());
setID("stagnation flow");
// Find indices for radiating species
@ -191,7 +191,7 @@ void StFlow::setGasAtMidpoint(const doublereal* x, size_t j)
for (size_t k = 0; k < m_nsp; k++) {
m_ybar[k] = 0.5*(yyj[k] + yyjp[k]);
}
m_thermo->setMassFractions_NoNorm(DATA_PTR(m_ybar));
m_thermo->setMassFractions_NoNorm(m_ybar.data());
m_thermo->setPressure(m_press);
}
@ -456,7 +456,7 @@ void StFlow::updateTransport(doublereal* x, size_t j0, size_t j1)
for (size_t j = j0; j < j1; j++) {
setGasAtMidpoint(x,j);
m_visc[j] = (m_dovisc ? m_trans->viscosity() : 0.0);
m_trans->getMixDiffCoeffs(DATA_PTR(m_diff) + j*m_nsp);
m_trans->getMixDiffCoeffs(&m_diff[j*m_nsp]);
m_tcon[j] = m_trans->thermalConductivity();
}
} else if (m_transport_option == c_Multi_Transport) {
@ -651,7 +651,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
np = x.size();
debuglog("Grid contains "+int2str(np)+" points.\n", loglevel >= 2);
readgrid = true;
setupGrid(np, DATA_PTR(x));
setupGrid(np, x.data());
}
}
if (!readgrid) {
@ -798,31 +798,30 @@ XML_Node& StFlow::save(XML_Node& o, const doublereal* const sol)
XML_Node& gv = flow.addChild("grid_data");
addFloat(flow, "pressure", m_press, "Pa", "pressure");
addFloatArray(gv,"z",m_z.size(),DATA_PTR(m_z),
addFloatArray(gv,"z",m_z.size(), m_z.data(),
"m","length");
vector_fp x(soln.nColumns());
soln.getRow(0,DATA_PTR(x));
addFloatArray(gv,"u",x.size(),DATA_PTR(x),"m/s","velocity");
soln.getRow(0, x.data());
addFloatArray(gv,"u",x.size(),x.data(),"m/s","velocity");
soln.getRow(1,DATA_PTR(x));
addFloatArray(gv,"V",
x.size(),DATA_PTR(x),"1/s","rate");
soln.getRow(1, x.data());
addFloatArray(gv,"V",x.size(),x.data(),"1/s","rate");
soln.getRow(2,DATA_PTR(x));
addFloatArray(gv,"T",x.size(),DATA_PTR(x),"K","temperature");
soln.getRow(2, x.data());
addFloatArray(gv,"T",x.size(),x.data(),"K","temperature");
soln.getRow(3,DATA_PTR(x));
addFloatArray(gv,"L",x.size(),DATA_PTR(x),"N/m^4");
soln.getRow(3, x.data());
addFloatArray(gv,"L",x.size(),x.data(),"N/m^4");
for (k = 0; k < m_nsp; k++) {
soln.getRow(4+k,DATA_PTR(x));
soln.getRow(4+k, x.data());
addFloatArray(gv,m_thermo->speciesName(k),
x.size(),DATA_PTR(x),"","massFraction");
x.size(),x.data(),"","massFraction");
}
if (m_do_radiation) {
addFloatArray(gv, "radiative_heat_loss", m_z.size(),
DATA_PTR(m_qdotRadiation), "W/m^3", "specificPower");
m_qdotRadiation.data(), "W/m^3", "specificPower");
}
vector_fp values(nPoints());
for (size_t i = 0; i < nPoints(); i++) {

14
src/oneD/boundaries1D.cpp
View file

@ -82,7 +82,7 @@ void Inlet1D::setMoleFractions(const std::string& xin)
m_xstr = xin;
if (m_flow) {
m_flow->phase().setMoleFractionsByName(xin);
m_flow->phase().getMassFractions(DATA_PTR(m_yin));
m_flow->phase().getMassFractions(m_yin.data());
needJacUpdate();
}
}
@ -91,7 +91,7 @@ void Inlet1D::setMoleFractions(const doublereal* xin)
{
if (m_flow) {
m_flow->phase().setMoleFractions(xin);
m_flow->phase().getMassFractions(DATA_PTR(m_yin));
m_flow->phase().getMassFractions(m_yin.data());
needJacUpdate();
}
}
@ -486,7 +486,7 @@ void OutletRes1D::setMoleFractions(const std::string& xres)
m_xstr = xres;
if (m_flow) {
m_flow->phase().setMoleFractionsByName(xres);
m_flow->phase().getMassFractions(DATA_PTR(m_yres));
m_flow->phase().getMassFractions(m_yres.data());
needJacUpdate();
}
}
@ -495,7 +495,7 @@ void OutletRes1D::setMoleFractions(const doublereal* xres)
{
if (m_flow) {
m_flow->phase().setMoleFractions(xres);
m_flow->phase().getMassFractions(DATA_PTR(m_yres));
m_flow->phase().getMassFractions(m_yres.data());
needJacUpdate();
}
}
@ -757,7 +757,7 @@ void ReactingSurf1D::eval(size_t jg, doublereal* xg, doublereal* rg,
sum += x[k+1];
}
m_sphase->setTemperature(x[0]);
m_sphase->setCoverages(DATA_PTR(m_work));
m_sphase->setCoverages(m_work.data());
// set the left gas state to the adjacent point
@ -775,7 +775,7 @@ void ReactingSurf1D::eval(size_t jg, doublereal* xg, doublereal* rg,
m_flow_right->setGas(xg + rightloc, 0);
}
m_kin->getNetProductionRates(DATA_PTR(m_work));
m_kin->getNetProductionRates(m_work.data());
doublereal rs0 = 1.0/m_sphase->siteDensity();
size_t ioffset = m_kin->kineticsSpeciesIndex(0, m_surfindex);
@ -804,7 +804,7 @@ void ReactingSurf1D::eval(size_t jg, doublereal* xg, doublereal* rg,
size_t nc;
if (m_flow_left) {
nc = m_flow_left->nComponents();
const doublereal* mwleft = DATA_PTR(m_phase_left->molecularWeights());
const vector_fp& mwleft = m_phase_left->molecularWeights();
rb =r - nc;
xb = x - nc;
rb[2] = xb[2] - x[0]; // specified T

8
src/thermo/DebyeHuckel.cpp
View file

@ -169,25 +169,25 @@ int DebyeHuckel::eosType() const
//
doublereal DebyeHuckel::enthalpy_mole() const
{
getPartialMolarEnthalpies(DATA_PTR(m_tmpV));
getPartialMolarEnthalpies(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal DebyeHuckel::entropy_mole() const
{
getPartialMolarEntropies(DATA_PTR(m_tmpV));
getPartialMolarEntropies(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal DebyeHuckel::gibbs_mole() const
{
getChemPotentials(DATA_PTR(m_tmpV));
getChemPotentials(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal DebyeHuckel::cp_mole() const
{
getPartialMolarCp(DATA_PTR(m_tmpV));
getPartialMolarCp(m_tmpV.data());
return mean_X(m_tmpV);
}

14
src/thermo/GibbsExcessVPSSTP.cpp
View file

@ -56,31 +56,31 @@ ThermoPhase* GibbsExcessVPSSTP::duplMyselfAsThermoPhase() const
void GibbsExcessVPSSTP::setMassFractions(const doublereal* const y)
{
Phase::setMassFractions(y);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void GibbsExcessVPSSTP::setMassFractions_NoNorm(const doublereal* const y)
{
Phase::setMassFractions_NoNorm(y);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void GibbsExcessVPSSTP::setMoleFractions(const doublereal* const x)
{
Phase::setMoleFractions(x);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void GibbsExcessVPSSTP::setMoleFractions_NoNorm(const doublereal* const x)
{
Phase::setMoleFractions_NoNorm(x);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void GibbsExcessVPSSTP::setConcentrations(const doublereal* const c)
{
Phase::setConcentrations(c);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
/*
@ -142,7 +142,7 @@ doublereal GibbsExcessVPSSTP::logStandardConc(size_t k) const
void GibbsExcessVPSSTP::getActivities(doublereal* ac) const
{
getActivityCoefficients(ac);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
for (size_t k = 0; k < m_kk; k++) {
ac[k] *= moleFractions_[k];
}
@ -201,7 +201,7 @@ void GibbsExcessVPSSTP::initThermo()
{
initLengths();
VPStandardStateTP::initThermo();
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void GibbsExcessVPSSTP::initLengths()

22
src/thermo/HMWSoln.cpp
View file

@ -399,16 +399,16 @@ int HMWSoln::eosType() const
//
doublereal HMWSoln::enthalpy_mole() const
{
getPartialMolarEnthalpies(DATA_PTR(m_tmpV));
getMoleFractions(DATA_PTR(m_pp));
getPartialMolarEnthalpies(m_tmpV.data());
getMoleFractions(m_pp.data());
return mean_X(m_tmpV);
}
doublereal HMWSoln::relative_enthalpy() const
{
getPartialMolarEnthalpies(DATA_PTR(m_tmpV));
getPartialMolarEnthalpies(m_tmpV.data());
double hbar = mean_X(m_tmpV);
getEnthalpy_RT(DATA_PTR(m_gamma_tmp));
getEnthalpy_RT(m_gamma_tmp.data());
for (size_t k = 0; k < m_kk; k++) {
m_gamma_tmp[k] *= RT();
}
@ -419,7 +419,7 @@ doublereal HMWSoln::relative_enthalpy() const
doublereal HMWSoln::relative_molal_enthalpy() const
{
double L = relative_enthalpy();
getMoleFractions(DATA_PTR(m_tmpV));
getMoleFractions(m_tmpV.data());
double xanion = 0.0;
size_t kcation = npos;
double xcation = 0.0;
@ -458,19 +458,19 @@ doublereal HMWSoln::relative_molal_enthalpy() const
doublereal HMWSoln::entropy_mole() const
{
getPartialMolarEntropies(DATA_PTR(m_tmpV));
getPartialMolarEntropies(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal HMWSoln::gibbs_mole() const
{
getChemPotentials(DATA_PTR(m_tmpV));
getChemPotentials(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal HMWSoln::cp_mole() const
{
getPartialMolarCp(DATA_PTR(m_tmpV));
getPartialMolarCp(m_tmpV.data());
return mean_X(m_tmpV);
}
@ -589,7 +589,7 @@ void HMWSoln::getActivityConcentrations(doublereal* c) const
doublereal HMWSoln::standardConcentration(size_t k) const
{
getStandardVolumes(DATA_PTR(m_tmpV));
getStandardVolumes(m_tmpV.data());
double mvSolvent = m_tmpV[m_indexSolvent];
if (k > 0) {
return m_Mnaught / mvSolvent;
@ -1268,7 +1268,7 @@ void HMWSoln::calcMolalitiesCropped() const
}
if (cropMethod == 1) {
double* molF = DATA_PTR(m_gamma_tmp);
double* molF = m_gamma_tmp.data();
getMoleFractions(molF);
double xmolSolvent = molF[m_indexSolvent];
if (xmolSolvent >= MC_X_o_cutoff_) {
@ -1586,7 +1586,7 @@ void HMWSoln::s_updatePitzer_lnMolalityActCoeff() const
/*
* Use the CROPPED molality of the species in solution.
*/
const double* molality = DATA_PTR(m_molalitiesCropped);
const vector_fp& molality = m_molalitiesCropped;
/*
* These are data inputs about the Pitzer correlation. They come

4
src/thermo/HMWSoln_input.cpp
View file

@ -1530,7 +1530,7 @@ void HMWSoln::initThermoXML(XML_Node& phaseNode, const std::string& id_)
* Lastly calculate the charge balance and then add stuff until the charges compensate
*/
vector_fp mf(m_kk, 0.0);
getMoleFractions(DATA_PTR(mf));
getMoleFractions(mf.data());
bool notDone = true;
while (notDone) {
@ -1585,7 +1585,7 @@ void HMWSoln::initThermoXML(XML_Node& phaseNode, const std::string& id_)
}
}
}
setMoleFractions(DATA_PTR(mf));
setMoleFractions(mf.data());
} else {
notDone = false;
}

12
src/thermo/IdealMolalSoln.cpp
View file

@ -135,32 +135,32 @@ ThermoPhase* IdealMolalSoln::duplMyselfAsThermoPhase() const
doublereal IdealMolalSoln::enthalpy_mole() const
{
getPartialMolarEnthalpies(DATA_PTR(m_tmpV));
getMoleFractions(DATA_PTR(m_pp));
getPartialMolarEnthalpies(m_tmpV.data());
getMoleFractions(m_pp.data());
return mean_X(m_tmpV);
}
doublereal IdealMolalSoln::intEnergy_mole() const
{
getPartialMolarEnthalpies(DATA_PTR(m_tmpV));
getPartialMolarEnthalpies(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal IdealMolalSoln::entropy_mole() const
{
getPartialMolarEntropies(DATA_PTR(m_tmpV));
getPartialMolarEntropies(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal IdealMolalSoln::gibbs_mole() const
{
getChemPotentials(DATA_PTR(m_tmpV));
getChemPotentials(m_tmpV.data());
return mean_X(m_tmpV);
}
doublereal IdealMolalSoln::cp_mole() const
{
getPartialMolarCp(DATA_PTR(m_tmpV));
getPartialMolarCp(m_tmpV.data());
return mean_X(m_tmpV);
}

9
src/thermo/IdealSolidSolnPhase.cpp
View file

@ -350,20 +350,18 @@ void IdealSolidSolnPhase::getPartialMolarVolumes(doublereal* vbar) const
void IdealSolidSolnPhase::getPureGibbs(doublereal* gpure) const
{
const vector_fp& gibbsrt = gibbs_RT_ref();
const doublereal* const gk = DATA_PTR(gibbsrt);
doublereal delta_p = (m_Pcurrent - m_Pref);
for (size_t k = 0; k < m_kk; k++) {
gpure[k] = RT() * gk[k] + delta_p * m_speciesMolarVolume[k];
gpure[k] = RT() * gibbsrt[k] + delta_p * m_speciesMolarVolume[k];
}
}
void IdealSolidSolnPhase::getGibbs_RT(doublereal* grt) const
{
const vector_fp& gibbsrt = gibbs_RT_ref();
const doublereal* const gk = DATA_PTR(gibbsrt);
doublereal delta_prt = (m_Pcurrent - m_Pref)/ RT();
for (size_t k = 0; k < m_kk; k++) {
grt[k] = gk[k] + delta_prt * m_speciesMolarVolume[k];
grt[k] = gibbsrt[k] + delta_prt * m_speciesMolarVolume[k];
}
}
@ -601,8 +599,7 @@ void IdealSolidSolnPhase::_updateThermo() const
/*
* Update the thermodynamic functions of the reference state.
*/
m_spthermo->update(tnow, DATA_PTR(m_cp0_R), DATA_PTR(m_h0_RT),
DATA_PTR(m_s0_R));
m_spthermo->update(tnow, m_cp0_R.data(), m_h0_RT.data(), m_s0_R.data());
m_tlast = tnow;
doublereal rrt = 1.0 / (GasConstant * tnow);
for (size_t k = 0; k < m_kk; k++) {

38
src/thermo/IonsFromNeutralVPSSTP.cpp
View file

@ -246,32 +246,32 @@ int IonsFromNeutralVPSSTP::eosType() const
doublereal IonsFromNeutralVPSSTP::enthalpy_mole() const
{
getPartialMolarEnthalpies(DATA_PTR(m_pp));
getPartialMolarEnthalpies(m_pp.data());
return mean_X(m_pp);
}
doublereal IonsFromNeutralVPSSTP::entropy_mole() const
{
getPartialMolarEntropies(DATA_PTR(m_pp));
getPartialMolarEntropies(m_pp.data());
return mean_X(m_pp);
}
doublereal IonsFromNeutralVPSSTP::gibbs_mole() const
{
getChemPotentials(DATA_PTR(m_pp));
getChemPotentials(m_pp.data());
return mean_X(m_pp);
}
doublereal IonsFromNeutralVPSSTP::cp_mole() const
{
getPartialMolarCp(DATA_PTR(m_pp));
getPartialMolarCp(m_pp.data());
return mean_X(m_pp);
}
doublereal IonsFromNeutralVPSSTP::cv_mole() const
{
// Need to revisit this, as it is wrong
getPartialMolarCp(DATA_PTR(m_pp));
getPartialMolarCp(m_pp.data());
return mean_X(m_pp);
}
@ -314,7 +314,7 @@ void IonsFromNeutralVPSSTP::getChemPotentials(doublereal* mu) const
/*
* Get the standard chemical potentials of netural molecules
*/
neutralMoleculePhase_->getStandardChemPotentials(DATA_PTR(muNeutralMolecule_));
neutralMoleculePhase_->getStandardChemPotentials(muNeutralMolecule_.data());
doublereal RT_ = GasConstant * temperature();
@ -323,7 +323,7 @@ void IonsFromNeutralVPSSTP::getChemPotentials(doublereal* mu) const
neutralMoleculePhase_->getChemPotentials(mu);
break;
case cIonSolnType_SINGLEANION:
neutralMoleculePhase_->getLnActivityCoefficients(DATA_PTR(lnActCoeff_NeutralMolecule_));
neutralMoleculePhase_->getLnActivityCoefficients(lnActCoeff_NeutralMolecule_.data());
fact2 = 2.0 * RT_ * log(2.0);
// Do the cation list
@ -473,7 +473,7 @@ void IonsFromNeutralVPSSTP::calcIonMoleFractions(doublereal* const mf) const
* Download the neutral mole fraction vector into the
* vector, NeutralMolecMoleFractions_[]
*/
neutralMoleculePhase_->getMoleFractions(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->getMoleFractions(NeutralMolecMoleFractions_.data());
// Zero the mole fractions
for (size_t k = 0; k < m_kk; k++) {
@ -676,35 +676,35 @@ void IonsFromNeutralVPSSTP::setMassFractions(const doublereal* const y)
{
GibbsExcessVPSSTP::setMassFractions(y);
calcNeutralMoleculeMoleFractions();
neutralMoleculePhase_->setMoleFractions(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->setMoleFractions(NeutralMolecMoleFractions_.data());
}
void IonsFromNeutralVPSSTP::setMassFractions_NoNorm(const doublereal* const y)
{
GibbsExcessVPSSTP::setMassFractions_NoNorm(y);
calcNeutralMoleculeMoleFractions();
neutralMoleculePhase_->setMoleFractions(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->setMoleFractions(NeutralMolecMoleFractions_.data());
}
void IonsFromNeutralVPSSTP::setMoleFractions(const doublereal* const x)
{
GibbsExcessVPSSTP::setMoleFractions(x);
calcNeutralMoleculeMoleFractions();
neutralMoleculePhase_->setMoleFractions(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->setMoleFractions(NeutralMolecMoleFractions_.data());
}
void IonsFromNeutralVPSSTP::setMoleFractions_NoNorm(const doublereal* const x)
{
GibbsExcessVPSSTP::setMoleFractions_NoNorm(x);
calcNeutralMoleculeMoleFractions();
neutralMoleculePhase_->setMoleFractions_NoNorm(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->setMoleFractions_NoNorm(NeutralMolecMoleFractions_.data());
}
void IonsFromNeutralVPSSTP::setConcentrations(const doublereal* const c)
{
GibbsExcessVPSSTP::setConcentrations(c);
calcNeutralMoleculeMoleFractions();
neutralMoleculePhase_->setMoleFractions(DATA_PTR(NeutralMolecMoleFractions_));
neutralMoleculePhase_->setMoleFractions(NeutralMolecMoleFractions_.data());
}
/*
@ -951,7 +951,7 @@ void IonsFromNeutralVPSSTP::s_update_lnActCoeff() const
/*
* Get the activity coefficiens of the neutral molecules
*/
neutralMoleculePhase_->getLnActivityCoefficients(DATA_PTR(lnActCoeff_NeutralMolecule_));
neutralMoleculePhase_->getLnActivityCoefficients(lnActCoeff_NeutralMolecule_.data());
switch (ionSolnType_) {
case cIonSolnType_PASSTHROUGH:
@ -1005,10 +1005,10 @@ void IonsFromNeutralVPSSTP::getdlnActCoeffds(const doublereal dTds, const double
return;
}
getNeutralMoleculeMoleGrads(DATA_PTR(dXds),DATA_PTR(dX_NeutralMolecule_));
getNeutralMoleculeMoleGrads(dXds, dX_NeutralMolecule_.data());
// All mole fractions returned to normal
geThermo->getdlnActCoeffds(dTds, DATA_PTR(dX_NeutralMolecule_), DATA_PTR(dlnActCoeff_NeutralMolecule_));
geThermo->getdlnActCoeffds(dTds, dX_NeutralMolecule_.data(), dlnActCoeff_NeutralMolecule_.data());
switch (ionSolnType_) {
case cIonSolnType_PASSTHROUGH:
@ -1059,7 +1059,7 @@ void IonsFromNeutralVPSSTP::s_update_dlnActCoeffdT() const
return;
}
geThermo->getdlnActCoeffdT(DATA_PTR(dlnActCoeffdT_NeutralMolecule_));
geThermo->getdlnActCoeffdT(dlnActCoeffdT_NeutralMolecule_.data());
switch (ionSolnType_) {
case cIonSolnType_PASSTHROUGH:
@ -1110,7 +1110,7 @@ void IonsFromNeutralVPSSTP::s_update_dlnActCoeff_dlnX_diag() const
return;
}
geThermo->getdlnActCoeffdlnX_diag(DATA_PTR(dlnActCoeffdlnX_diag_NeutralMolecule_));
geThermo->getdlnActCoeffdlnX_diag(dlnActCoeffdlnX_diag_NeutralMolecule_.data());
switch (ionSolnType_) {
case cIonSolnType_PASSTHROUGH:
@ -1161,7 +1161,7 @@ void IonsFromNeutralVPSSTP::s_update_dlnActCoeff_dlnN_diag() const
return;
}
geThermo->getdlnActCoeffdlnN_diag(DATA_PTR(dlnActCoeffdlnN_diag_NeutralMolecule_));
geThermo->getdlnActCoeffdlnN_diag(dlnActCoeffdlnN_diag_NeutralMolecule_.data());
switch (ionSolnType_) {
case cIonSolnType_PASSTHROUGH:

10
src/thermo/LatticeSolidPhase.cpp
View file

@ -209,7 +209,7 @@ void LatticeSolidPhase::setMoleFractions(const doublereal* const x)
for (size_t k = 0; k < strt; k++) {
m_x[k] = x[k] / m_nlattice;
}
Phase::setMoleFractions(DATA_PTR(m_x));
Phase::setMoleFractions(m_x.data());
calcDensity();
}
@ -379,7 +379,7 @@ void LatticeSolidPhase::initThermo()
}
lkstart_[n+1] = loc;
}
setMoleFractions(DATA_PTR(m_x));
setMoleFractions(m_x.data());
ThermoPhase::initThermo();
}
@ -395,11 +395,11 @@ void LatticeSolidPhase::_updateThermo() const
{
doublereal tnow = temperature();
if (m_tlast != tnow) {
getMoleFractions(DATA_PTR(m_x));
getMoleFractions(m_x.data());
size_t strt = 0;
for (size_t n = 0; n < m_nlattice; n++) {
m_lattice[n]->setTemperature(tnow);
m_lattice[n]->setMoleFractions(DATA_PTR(m_x) + strt);
m_lattice[n]->setMoleFractions(&m_x[strt]);
m_lattice[n]->setPressure(m_press);
strt += m_lattice[n]->nSpecies();
}
@ -419,7 +419,7 @@ void LatticeSolidPhase::setLatticeMoleFractionsByName(int nn, const std::string&
loc++;
}
}
setMoleFractions(DATA_PTR(m_x));
setMoleFractions(m_x.data());
}
void LatticeSolidPhase::setParametersFromXML(const XML_Node& eosdata)

3
src/thermo/MaskellSolidSolnPhase.cpp
View file

@ -294,8 +294,7 @@ void MaskellSolidSolnPhase::_updateThermo() const
*/
doublereal tnow = temperature();
if (!cached.validate(tnow)) {
m_spthermo->update(tnow, DATA_PTR(m_cp0_R), DATA_PTR(m_h0_RT),
DATA_PTR(m_s0_R));
m_spthermo->update(tnow, m_cp0_R.data(), m_h0_RT.data(), m_s0_R.data());
for (size_t k = 0; k < m_kk; k++) {
m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];
}

16
src/thermo/MixtureFugacityTP.cpp
View file

@ -290,37 +290,37 @@ void MixtureFugacityTP::setPressure(doublereal p)
void MixtureFugacityTP::setMassFractions(const doublereal* const y)
{
Phase::setMassFractions(y);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void MixtureFugacityTP::setMassFractions_NoNorm(const doublereal* const y)
{
Phase::setMassFractions_NoNorm(y);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void MixtureFugacityTP::setMoleFractions(const doublereal* const x)
{
Phase::setMoleFractions(x);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void MixtureFugacityTP::setMoleFractions_NoNorm(const doublereal* const x)
{
Phase::setMoleFractions_NoNorm(x);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void MixtureFugacityTP::setConcentrations(const doublereal* const c)
{
Phase::setConcentrations(c);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
}
void MixtureFugacityTP::setMoleFractions_NoState(const doublereal* const x)
{
Phase::setMoleFractions(x);
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
updateMixingExpressions();
}
@ -341,7 +341,7 @@ void MixtureFugacityTP::setState_TP(doublereal t, doublereal pres)
* Therefore, we need to do the standard state thermo calc with the
* (t, pres) combo.
*/
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
Phase::setTemperature(t);
_updateReferenceStateThermo();
@ -406,7 +406,7 @@ void MixtureFugacityTP::setState_TP(doublereal t, doublereal pres)
void MixtureFugacityTP::setState_TR(doublereal T, doublereal rho)
{
getMoleFractions(DATA_PTR(moleFractions_));
getMoleFractions(moleFractions_.data());
Phase::setTemperature(T);
_updateReferenceStateThermo();
Phase::setDensity(rho);

10
src/thermo/MolalityVPSSTP.cpp
View file

@ -128,7 +128,7 @@ doublereal MolalityVPSSTP::moleFSolventMin() const
void MolalityVPSSTP::calcMolalities() const
{
getMoleFractions(DATA_PTR(m_molalities));
getMoleFractions(m_molalities.data());
double xmolSolvent = std::max(m_molalities[m_indexSolvent], m_xmolSolventMIN);
double denomInv = 1.0/ (m_Mnaught * xmolSolvent);
for (size_t k = 0; k < m_kk; k++) {
@ -164,7 +164,7 @@ void MolalityVPSSTP::setMolalities(const doublereal* const molal)
m_molalities[k] *= tmp;
}
}
setMoleFractions(DATA_PTR(m_molalities));
setMoleFractions(m_molalities.data());
/*
* Essentially we don't trust the input: We calculate
* the molalities from the mole fractions that we
@ -184,7 +184,7 @@ void MolalityVPSSTP::setMolalitiesByName(const compositionMap& mMap)
* Get a vector of mole fractions
*/
vector_fp mf(m_kk, 0.0);
getMoleFractions(DATA_PTR(mf));
getMoleFractions(mf.data());
double xmolSmin = std::max(mf[m_indexSolvent], m_xmolSolventMIN);
for (size_t k = 0; k < m_kk; k++) {
double mol_k = getValue(mMap, speciesName(k), 0.0);
@ -239,7 +239,7 @@ void MolalityVPSSTP::setMolalitiesByName(const compositionMap& mMap)
for (size_t k = 0; k < m_kk; k++) {
mf[k] *= sum;
}
setMoleFractions(DATA_PTR(mf));
setMoleFractions(mf.data());
/*
* After we formally set the mole fractions, we
* calculate the molalities again and store it in
@ -300,7 +300,7 @@ doublereal MolalityVPSSTP::osmoticCoefficient() const
* First, we calculate the activities all over again
*/
vector_fp act(m_kk);
getActivities(DATA_PTR(act));
getActivities(act.data());
/*
* Then, we calculate the sum of the solvent molalities
*/

20
src/thermo/PDSS_IonsFromNeutral.cpp
View file

@ -208,7 +208,7 @@ void PDSS_IonsFromNeutral::initThermo()
doublereal PDSS_IonsFromNeutral::enthalpy_RT() const
{
neutralMoleculePhase_->getEnthalpy_RT(DATA_PTR(tmpNM));
neutralMoleculePhase_->getEnthalpy_RT(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -224,7 +224,7 @@ doublereal PDSS_IonsFromNeutral::intEnergy_mole() const
doublereal PDSS_IonsFromNeutral::entropy_R() const
{
neutralMoleculePhase_->getEntropy_R(DATA_PTR(tmpNM));
neutralMoleculePhase_->getEntropy_R(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -238,7 +238,7 @@ doublereal PDSS_IonsFromNeutral::entropy_R() const
doublereal PDSS_IonsFromNeutral::gibbs_RT() const
{
neutralMoleculePhase_->getGibbs_RT(DATA_PTR(tmpNM));
neutralMoleculePhase_->getGibbs_RT(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -252,7 +252,7 @@ doublereal PDSS_IonsFromNeutral::gibbs_RT() const
doublereal PDSS_IonsFromNeutral::cp_R() const
{
neutralMoleculePhase_->getCp_R(DATA_PTR(tmpNM));
neutralMoleculePhase_->getCp_R(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -263,7 +263,7 @@ doublereal PDSS_IonsFromNeutral::cp_R() const
doublereal PDSS_IonsFromNeutral::molarVolume() const
{
neutralMoleculePhase_->getStandardVolumes(DATA_PTR(tmpNM));
neutralMoleculePhase_->getStandardVolumes(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -279,7 +279,7 @@ doublereal PDSS_IonsFromNeutral::density() const
doublereal PDSS_IonsFromNeutral::gibbs_RT_ref() const
{
neutralMoleculePhase_->getGibbs_RT_ref(DATA_PTR(tmpNM));
neutralMoleculePhase_->getGibbs_RT_ref(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -293,7 +293,7 @@ doublereal PDSS_IonsFromNeutral::gibbs_RT_ref() const
doublereal PDSS_IonsFromNeutral::enthalpy_RT_ref() const
{
neutralMoleculePhase_->getEnthalpy_RT_ref(DATA_PTR(tmpNM));
neutralMoleculePhase_->getEnthalpy_RT_ref(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -304,7 +304,7 @@ doublereal PDSS_IonsFromNeutral::enthalpy_RT_ref() const
doublereal PDSS_IonsFromNeutral::entropy_R_ref() const
{
neutralMoleculePhase_->getEntropy_R_ref(DATA_PTR(tmpNM));
neutralMoleculePhase_->getEntropy_R_ref(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -318,7 +318,7 @@ doublereal PDSS_IonsFromNeutral::entropy_R_ref() const
doublereal PDSS_IonsFromNeutral::cp_R_ref() const
{
neutralMoleculePhase_->getCp_R_ref(DATA_PTR(tmpNM));
neutralMoleculePhase_->getCp_R_ref(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];
@ -329,7 +329,7 @@ doublereal PDSS_IonsFromNeutral::cp_R_ref() const
doublereal PDSS_IonsFromNeutral::molarVolume_ref() const
{
neutralMoleculePhase_->getStandardVolumes_ref(DATA_PTR(tmpNM));
neutralMoleculePhase_->getStandardVolumes_ref(tmpNM.data());
doublereal val = 0.0;
for (size_t i = 0; i < numMult_; i++) {
size_t jNeut = idNeutralMoleculeVec[i];

10
src/thermo/RedlichKwongMFTP.cpp
View file

@ -194,7 +194,7 @@ void RedlichKwongMFTP::calcDensity()
* Calculate the molarVolume of the solution (m**3 kmol-1)
*/
const doublereal* const dtmp = moleFractdivMMW();
getPartialMolarVolumes(DATA_PTR(m_tmpV));
getPartialMolarVolumes(m_tmpV.data());
double invDens = dot(m_tmpV.begin(), m_tmpV.end(), dtmp);
/*
* Set the density in the parent State object directly,
@ -242,7 +242,7 @@ void RedlichKwongMFTP::setConcentrations(const doublereal* const c)
void RedlichKwongMFTP::getActivityConcentrations(doublereal* c) const
{
getPartialMolarVolumes(DATA_PTR(m_partialMolarVolumes));
getPartialMolarVolumes(m_partialMolarVolumes.data());
for (size_t k = 0; k < m_kk; k++) {
c[k] = moleFraction(k) / m_partialMolarVolumes[k];
}
@ -250,7 +250,7 @@ void RedlichKwongMFTP::getActivityConcentrations(doublereal* c) const
doublereal RedlichKwongMFTP::standardConcentration(size_t k) const
{
getStandardVolumes(DATA_PTR(m_tmpV));
getStandardVolumes(m_tmpV.data());
return 1.0 / m_tmpV[k];
}
@ -424,7 +424,7 @@ void RedlichKwongMFTP::getPartialMolarEntropies(doublereal* sbar) const
}
pressureDerivatives();
getPartialMolarVolumes(DATA_PTR(m_partialMolarVolumes));
getPartialMolarVolumes(m_partialMolarVolumes.data());
for (size_t k = 0; k < m_kk; k++) {
sbar[k] -= -m_partialMolarVolumes[k] * dpdT_;
}
@ -570,7 +570,7 @@ void RedlichKwongMFTP::setToEquilState(const doublereal* mu_RT)
{
double tmp, tmp2;
_updateReferenceStateThermo();
getGibbs_RT_ref(DATA_PTR(m_tmpV));
getGibbs_RT_ref(m_tmpV.data());
/*
* Within the method, we protect against inf results if the

2
src/thermo/SemiconductorPhase.cpp
View file

@ -15,7 +15,7 @@ SemiconductorPhase::SemiconductorPhase(std::string infile,
void SemiconductorPhase::getChemPotentials(doublereal* mu) const
{
getActivityConcentrations(DATA_PTR(m_work));
getActivityConcentrations(m_work.data());
mu[0] = ec() + GasConstant*temperature()*(JoyceDixon(m_work[0]/nc()));
mu[1] = ev() + GasConstant*temperature()*(log(m_work[1]/nv()));
}

3
src/thermo/SingleSpeciesTP.cpp
View file

@ -329,8 +329,7 @@ void SingleSpeciesTP::_updateThermo() const
{
doublereal tnow = temperature();
if (m_tlast != tnow) {
m_spthermo->update(tnow, DATA_PTR(m_cp0_R), DATA_PTR(m_h0_RT),
DATA_PTR(m_s0_R));
m_spthermo->update(tnow, m_cp0_R.data(), m_h0_RT.data(), m_s0_R.data());
m_tlast = tnow;
}
}

13
src/thermo/SurfPhase.cpp
View file

@ -144,7 +144,7 @@ void SurfPhase::getChemPotentials(doublereal* mu) const
{
_updateThermo();
copy(m_mu0.begin(), m_mu0.end(), mu);
getActivityConcentrations(DATA_PTR(m_work));
getActivityConcentrations(m_work.data());
for (size_t k = 0; k < m_kk; k++) {
mu[k] += GasConstant * temperature() *
(log(m_work[k]) - logStandardConc(k));
@ -243,7 +243,7 @@ void SurfPhase::initThermo()
m_work.resize(m_kk);
vector_fp cov(m_kk, 0.0);
cov[0] = 1.0;
setCoverages(DATA_PTR(cov));
setCoverages(cov.data());
m_logsize.resize(m_kk);
for (size_t k = 0; k < m_kk; k++) {
m_logsize[k] = log(size(k));
@ -277,7 +277,7 @@ void SurfPhase::setCoverages(const doublereal* theta)
* Call the Phase:: class function
* setConcentrations.
*/
setConcentrations(DATA_PTR(m_work));
setConcentrations(m_work.data());
}
void SurfPhase::setCoveragesNoNorm(const doublereal* theta)
@ -289,7 +289,7 @@ void SurfPhase::setCoveragesNoNorm(const doublereal* theta)
* Call the Phase:: class function
* setConcentrations.
*/
setConcentrations(DATA_PTR(m_work));
setConcentrations(m_work.data());
}
void SurfPhase::getCoverages(doublereal* theta) const
@ -320,15 +320,14 @@ void SurfPhase::setCoveragesByName(const compositionMap& cov)
throw CanteraError("SurfPhase::setCoveragesByName",
"Input coverages are all zero or negative");
}
setCoverages(DATA_PTR(cv));
setCoverages(cv.data());
}
void SurfPhase::_updateThermo(bool force) const
{
doublereal tnow = temperature();
if (m_tlast != tnow || force) {
m_spthermo->update(tnow, DATA_PTR(m_cp0), DATA_PTR(m_h0),
DATA_PTR(m_s0));
m_spthermo->update(tnow, m_cp0.data(), m_h0.data(), m_s0.data());
m_tlast = tnow;
for (size_t k = 0; k < m_kk; k++) {
m_h0[k] *= GasConstant * tnow;

10
src/thermo/ThermoPhase.cpp
View file

@ -852,9 +852,9 @@ void ThermoPhase::getdlnActCoeffdlnN_numderiv(const size_t ld, doublereal* const
* Evaluate the current base activity coefficients if necessary
*/
vector_fp ActCoeff_Base(m_kk);
getActivityCoefficients(DATA_PTR(ActCoeff_Base));
getActivityCoefficients(ActCoeff_Base.data());
vector_fp Xmol_Base(m_kk);
getMoleFractions(DATA_PTR(Xmol_Base));
getMoleFractions(Xmol_Base.data());
// Make copies of ActCoeff and Xmol_ for use in taking differences
vector_fp ActCoeff(m_kk);
@ -889,8 +889,8 @@ void ThermoPhase::getdlnActCoeffdlnN_numderiv(const size_t ld, doublereal* const
* Go get new values for the activity coefficients.
* -> Note this calls setState_PX();
*/
setState_PX(pres, DATA_PTR(Xmol));
getActivityCoefficients(DATA_PTR(ActCoeff));
setState_PX(pres, Xmol.data());
getActivityCoefficients(ActCoeff.data());
/*
* Calculate the column of the matrix
@ -912,7 +912,7 @@ void ThermoPhase::getdlnActCoeffdlnN_numderiv(const size_t ld, doublereal* const
* -> Just wanted to make sure that cantera is in sync
* with VolPhase after this call.
*/
setState_PX(pres, DATA_PTR(Xmol_Base));
setState_PX(pres, Xmol_Base.data());
}
std::string ThermoPhase::report(bool show_thermo, doublereal threshold) const

8
src/transport/DustyGasTransport.cpp
View file

@ -104,7 +104,7 @@ void DustyGasTransport::initialize(ThermoPhase* phase, Transport* gastr)
m_dk.resize(m_nsp, 0.0);
m_x.resize(m_nsp, 0.0);
m_thermo->getMoleFractions(DATA_PTR(m_x));
m_thermo->getMoleFractions(m_x.data());
// set flags all false
m_knudsen_ok = false;
@ -174,8 +174,8 @@ void DustyGasTransport::getMolarFluxes(const doublereal* const state1,
{
doublereal conc1, conc2;
// cbar will be the average concentration between the two points
doublereal* const cbar = DATA_PTR(m_spwork);
doublereal* const gradc = DATA_PTR(m_spwork2);
doublereal* const cbar = m_spwork.data();
doublereal* const gradc = m_spwork2.data();
const doublereal t1 = state1[0];
const doublereal t2 = state2[0];
const doublereal rho1 = state1[1];
@ -264,7 +264,7 @@ void DustyGasTransport::updateTransport_T()
void DustyGasTransport::updateTransport_C()
{
m_thermo->getMoleFractions(DATA_PTR(m_x));
m_thermo->getMoleFractions(m_x.data());
// add an offset to avoid a pure species condition
// (check - this may be unnecessary)

32
src/transport/GasTransport.cpp
View file

@ -143,7 +143,7 @@ doublereal GasTransport::viscosity()
updateViscosity_T();
}
multiply(m_phi, DATA_PTR(m_molefracs), DATA_PTR(m_spwork));
multiply(m_phi, m_molefracs.data(), m_spwork.data());
for (size_t k = 0; k < m_nsp; k++) {
vismix += m_molefracs[k] * m_visc[k]/m_spwork[k]; //denom;
@ -542,10 +542,8 @@ void GasTransport::fitCollisionIntegrals(MMCollisionInt& integrals)
if (dptr == fitlist.end()) {
vector_fp ca(degree+1), cb(degree+1), cc(degree+1);
vector_fp co22(degree+1);
integrals.fit(degree, dstar,
DATA_PTR(ca), DATA_PTR(cb), DATA_PTR(cc));
integrals.fit_omega22(degree, dstar,
DATA_PTR(co22));
integrals.fit(degree, dstar, ca.data(), cb.data(), cc.data());
integrals.fit_omega22(degree, dstar, co22.data());
m_omega22_poly.push_back(co22);
m_astar_poly.push_back(ca);
m_bstar_poly.push_back(cb);
@ -657,21 +655,21 @@ void GasTransport::fitProperties(MMCollisionInt& integrals)
w2[n] = 1.0/(spcond[n]*spcond[n]);
}
}
polyfit(np, DATA_PTR(tlog), DATA_PTR(spvisc),
DATA_PTR(w), degree, ndeg, 0.0, DATA_PTR(c));
polyfit(np, DATA_PTR(tlog), DATA_PTR(spcond),
DATA_PTR(w), degree, ndeg, 0.0, DATA_PTR(c2));
polyfit(np, tlog.data(), spvisc.data(),
w.data(), degree, ndeg, 0.0, c.data());
polyfit(np, tlog.data(), spcond.data(),
w.data(), degree, ndeg, 0.0, c2.data());
// evaluate max fit errors for viscosity
for (size_t n = 0; n < np; n++) {
double val, fit;
if (m_mode == CK_Mode) {
val = exp(spvisc[n]);
fit = exp(poly3(tlog[n], DATA_PTR(c)));
fit = exp(poly3(tlog[n], c.data()));
} else {
sqrt_T = exp(0.5*tlog[n]);
val = sqrt_T * pow(spvisc[n],2);
fit = sqrt_T * pow(poly4(tlog[n], DATA_PTR(c)),2);
fit = sqrt_T * pow(poly4(tlog[n], c.data()),2);
}
err = fit - val;
relerr = err/val;
@ -684,11 +682,11 @@ void GasTransport::fitProperties(MMCollisionInt& integrals)
double val, fit;
if (m_mode == CK_Mode) {
val = exp(spcond[n]);
fit = exp(poly3(tlog[n], DATA_PTR(c2)));
fit = exp(poly3(tlog[n], c2.data()));
} else {
sqrt_T = exp(0.5*tlog[n]);
val = sqrt_T * spcond[n];
fit = sqrt_T * poly4(tlog[n], DATA_PTR(c2));
fit = sqrt_T * poly4(tlog[n], c2.data());
}
err = fit - val;
relerr = err/val;
@ -758,19 +756,19 @@ void GasTransport::fitProperties(MMCollisionInt& integrals)
w[n] = 1.0/(diff[n]*diff[n]);
}
}
polyfit(np, DATA_PTR(tlog), DATA_PTR(diff),
DATA_PTR(w), degree, ndeg, 0.0, DATA_PTR(c));
polyfit(np, tlog.data(), diff.data(),
w.data(), degree, ndeg, 0.0, c.data());
for (size_t n = 0; n < np; n++) {
double val, fit;
if (m_mode == CK_Mode) {
val = exp(diff[n]);
fit = exp(poly3(tlog[n], DATA_PTR(c)));
fit = exp(poly3(tlog[n], c.data()));
} else {
double t = exp(tlog[n]);
double pre = pow(t, 1.5);
val = pre * diff[n];
fit = pre * poly4(tlog[n], DATA_PTR(c));
fit = pre * poly4(tlog[n], c.data());
}
err = fit - val;
relerr = err/val;

2
src/transport/HighPressureGasTransport.cpp
View file

@ -251,7 +251,7 @@ void HighPressureGasTransport::getMultiDiffCoeffs(const size_t ld, doublereal* c
// evaluate L0000 if the temperature or concentrations have
// changed since it was last evaluated.
if (!m_l0000_ok) {
eval_L0000(DATA_PTR(molefracs));
eval_L0000(molefracs.data());
}
// invert L00,00

12
src/transport/LiquidTransport.cpp
View file

@ -528,7 +528,7 @@ void LiquidTransport::getBinaryDiffCoeffs(size_t ld, doublereal* d)
void LiquidTransport::getMobilities(doublereal* const mobil)
{
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
doublereal c1 = ElectronCharge / (Boltzmann * m_temp);
for (size_t k = 0; k < m_nsp; k++) {
mobil[k] = c1 * m_spwork[k];
@ -537,7 +537,7 @@ void LiquidTransport::getMobilities(doublereal* const mobil)
void LiquidTransport::getFluidMobilities(doublereal* const mobil_f)
{
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
doublereal c1 = 1.0 / (GasConstant * m_temp);
for (size_t k = 0; k < m_nsp; k++) {
mobil_f[k] = c1 * m_spwork[k];
@ -765,9 +765,9 @@ bool LiquidTransport::update_C()
int iStateNew = m_thermo->stateMFNumber();
if (iStateNew != m_iStateMF) {
qReturn = false;
m_thermo->getMassFractions(DATA_PTR(m_massfracs));
m_thermo->getMoleFractions(DATA_PTR(m_molefracs));
m_thermo->getConcentrations(DATA_PTR(m_concentrations));
m_thermo->getMassFractions(m_massfracs.data());
m_thermo->getMoleFractions(m_molefracs.data());
m_thermo->getConcentrations(m_concentrations.data());
concTot_ = 0.0;
concTot_tran_ = 0.0;
for (size_t k = 0; k < m_nsp; k++) {
@ -934,7 +934,7 @@ void LiquidTransport::stefan_maxwell_solve()
double T = m_thermo->temperature();
update_Grad_lnAC();
m_thermo->getActivityCoefficients(DATA_PTR(m_actCoeff));
m_thermo->getActivityCoefficients(m_actCoeff.data());
/*
* Calculate the electrochemical potential gradient. This is the

54
src/transport/MMCollisionInt.cpp
View file

@ -255,7 +255,7 @@ void MMCollisionInt::init(doublereal tsmin, doublereal tsmax, int log_level)
m_logTemp[i] = log(tstar[i+1]);
vector_fp c(DeltaDegree+1);
rmserr = fitDelta(0, i, DeltaDegree, DATA_PTR(c));
rmserr = fitDelta(0, i, DeltaDegree, c.data());
if (DEBUG_MODE_ENABLED && log_level > 3) {
writelogf("\ndelta* fit at T* = %.6g\n", tstar[i+1]);
writelog("omega22 = [" + vec2str(c) + "]\n");
@ -263,21 +263,21 @@ void MMCollisionInt::init(doublereal tsmin, doublereal tsmax, int log_level)
m_o22poly.push_back(c);
e22 = std::max(e22, rmserr);
rmserr = fitDelta(1, i, DeltaDegree, DATA_PTR(c));
rmserr = fitDelta(1, i, DeltaDegree, c.data());
m_apoly.push_back(c);
if (DEBUG_MODE_ENABLED && log_level > 3) {
writelog("A* = [" + vec2str(c) + "]\n");
}
ea = std::max(ea, rmserr);
rmserr = fitDelta(2, i, DeltaDegree, DATA_PTR(c));
rmserr = fitDelta(2, i, DeltaDegree, c.data());
m_bpoly.push_back(c);
if (DEBUG_MODE_ENABLED && log_level > 3) {
writelog("B* = [" + vec2str(c) + "]\n");
}
eb = std::max(eb, rmserr);
rmserr = fitDelta(3, i, DeltaDegree, DATA_PTR(c));
rmserr = fitDelta(3, i, DeltaDegree, c.data());
m_cpoly.push_back(c);
if (DEBUG_MODE_ENABLED && log_level > 3) {
writelog("C* = [" + vec2str(c) + "]\n");
@ -316,7 +316,7 @@ doublereal MMCollisionInt::fitDelta(int table, int ntstar, int degree, doublerea
return 0.0;
}
w[0] = -1.0;
return polyfit(8, delta, begin, DATA_PTR(w), degree, ndeg, 0.0, c);
return polyfit(8, delta, begin, w.data(), degree, ndeg, 0.0, c);
}
doublereal MMCollisionInt::omega22(double ts, double deltastar)
@ -337,11 +337,10 @@ doublereal MMCollisionInt::omega22(double ts, double deltastar)
if (deltastar == 0.0) {
values[i-i1] = omega22_table[8*i];
} else {
values[i-i1] = poly5(deltastar, DATA_PTR(m_o22poly[i]));
values[i-i1] = poly5(deltastar, m_o22poly[i].data());
}
}
return quadInterp(log(ts), DATA_PTR(m_logTemp)
+ i1, DATA_PTR(values));
return quadInterp(log(ts), &m_logTemp[i1], values.data());
}
doublereal MMCollisionInt::astar(double ts, double deltastar)
@ -362,11 +361,10 @@ doublereal MMCollisionInt::astar(double ts, double deltastar)
if (deltastar == 0.0) {
values[i-i1] = astar_table[8*(i + 1)];
} else {
values[i-i1] = poly5(deltastar, DATA_PTR(m_apoly[i]));
values[i-i1] = poly5(deltastar, m_apoly[i].data());
}
}
return quadInterp(log(ts), DATA_PTR(m_logTemp)
+ i1, DATA_PTR(values));
return quadInterp(log(ts), &m_logTemp[i1], values.data());
}
doublereal MMCollisionInt::bstar(double ts, double deltastar)
@ -387,11 +385,10 @@ doublereal MMCollisionInt::bstar(double ts, double deltastar)
if (deltastar == 0.0) {
values[i-i1] = bstar_table[8*(i + 1)];
} else {
values[i-i1] = poly5(deltastar, DATA_PTR(m_bpoly[i]));
values[i-i1] = poly5(deltastar, m_bpoly[i].data());
}
}
return quadInterp(log(ts), DATA_PTR(m_logTemp) + i1,
DATA_PTR(values));
return quadInterp(log(ts), &m_logTemp[i1], values.data());
}
doublereal MMCollisionInt::cstar(double ts, double deltastar)
@ -412,11 +409,10 @@ doublereal MMCollisionInt::cstar(double ts, double deltastar)
if (deltastar == 0.0) {
values[i-i1] = cstar_table[8*(i + 1)];
} else {
values[i-i1] = poly5(deltastar, DATA_PTR(m_cpoly[i]));
values[i-i1] = poly5(deltastar, m_cpoly[i].data());
}
}
return quadInterp(log(ts), DATA_PTR(m_logTemp) + i1,
DATA_PTR(values));
return quadInterp(log(ts), &m_logTemp[i1], values.data());
}
void MMCollisionInt::fit_omega22(int degree, doublereal deltastar,
@ -427,17 +423,16 @@ void MMCollisionInt::fit_omega22(int degree, doublereal deltastar,
vector_fp values(n);
doublereal rmserr;
vector_fp w(n);
doublereal* logT = DATA_PTR(m_logTemp) + m_nmin;
doublereal* logT = &m_logTemp[m_nmin];
for (i = 0; i < n; i++) {
if (deltastar == 0.0) {
values[i] = omega22_table[8*(i + m_nmin)];
} else {
values[i] = poly5(deltastar, DATA_PTR(m_o22poly[i+m_nmin]));
values[i] = poly5(deltastar, m_o22poly[i+m_nmin].data());
}
}
w[0]= -1.0;
rmserr = polyfit(n, logT, DATA_PTR(values),
DATA_PTR(w), degree, ndeg, 0.0, o22);
rmserr = polyfit(n, logT, values.data(), w.data(), degree, ndeg, 0.0, o22);
if (DEBUG_MODE_ENABLED && m_loglevel > 0 && rmserr > 0.01) {
writelogf("Warning: RMS error = %12.6g in omega_22 fit"
"with delta* = %12.6g\n", rmserr, deltastar);
@ -452,39 +447,36 @@ void MMCollisionInt::fit(int degree, doublereal deltastar,
vector_fp values(n);
doublereal rmserr;
vector_fp w(n);
doublereal* logT = DATA_PTR(m_logTemp) + m_nmin;
doublereal* logT = &m_logTemp[m_nmin];
for (i = 0; i < n; i++) {
if (deltastar == 0.0) {
values[i] = astar_table[8*(i + m_nmin + 1)];
} else {
values[i] = poly5(deltastar, DATA_PTR(m_apoly[i+m_nmin]));
values[i] = poly5(deltastar, m_apoly[i+m_nmin].data());
}
}
w[0]= -1.0;
rmserr = polyfit(n, logT, DATA_PTR(values),
DATA_PTR(w), degree, ndeg, 0.0, a);
rmserr = polyfit(n, logT, values.data(), w.data(), degree, ndeg, 0.0, a);
for (i = 0; i < n; i++) {
if (deltastar == 0.0) {
values[i] = bstar_table[8*(i + m_nmin + 1)];
} else {
values[i] = poly5(deltastar, DATA_PTR(m_bpoly[i+m_nmin]));
values[i] = poly5(deltastar, m_bpoly[i+m_nmin].data());
}
}
w[0]= -1.0;
rmserr = polyfit(n, logT, DATA_PTR(values),
DATA_PTR(w), degree, ndeg, 0.0, b);
rmserr = polyfit(n, logT, values.data(), w.data(), degree, ndeg, 0.0, b);
for (i = 0; i < n; i++) {
if (deltastar == 0.0) {
values[i] = cstar_table[8*(i + m_nmin + 1)];
} else {
values[i] = poly5(deltastar, DATA_PTR(m_cpoly[i+m_nmin]));
values[i] = poly5(deltastar, m_cpoly[i+m_nmin].data());
}
}
w[0]= -1.0;
rmserr = polyfit(n, logT, DATA_PTR(values),
DATA_PTR(w), degree, ndeg, 0.0, c);
rmserr = polyfit(n, logT, values.data(), w.data(), degree, ndeg, 0.0, c);
if (DEBUG_MODE_ENABLED && m_loglevel > 2) {
writelogf("\nT* fit at delta* = %.6g\n", deltastar);

6
src/transport/MixTransport.cpp
View file

@ -62,7 +62,7 @@ void MixTransport::init(ThermoPhase* thermo, int mode, int log_level)
void MixTransport::getMobilities(doublereal* const mobil)
{
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
doublereal c1 = ElectronCharge / (Boltzmann * m_temp);
for (size_t k = 0; k < m_nsp; k++) {
mobil[k] = c1 * m_spwork[k];
@ -101,7 +101,7 @@ void MixTransport::getSpeciesFluxes(size_t ndim, const doublereal* const grad_T,
{
update_T();
update_C();
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
const vector_fp& mw = m_thermo->molecularWeights();
const doublereal* y = m_thermo->massFractions();
doublereal rhon = m_thermo->molarDensity();
@ -144,7 +144,7 @@ void MixTransport::update_C()
// fractions.
m_visc_ok = false;
m_condmix_ok = false;
m_thermo->getMoleFractions(DATA_PTR(m_molefracs));
m_thermo->getMoleFractions(m_molefracs.data());
// add an offset to avoid a pure species condition
for (size_t k = 0; k < m_nsp; k++) {

44
src/transport/MultiTransport.cpp
View file

@ -148,22 +148,22 @@ void MultiTransport::solveLMatrixEquation()
m_Lmatrix.resize(3*m_nsp, 3*m_nsp, 0.0);
//! Evaluate the upper-left block of the L matrix.
eval_L0000(DATA_PTR(m_molefracs));
eval_L0010(DATA_PTR(m_molefracs));
eval_L0000(m_molefracs.data());
eval_L0010(m_molefracs.data());
eval_L0001();
eval_L1000();
eval_L1010(DATA_PTR(m_molefracs));
eval_L1001(DATA_PTR(m_molefracs));
eval_L1010(m_molefracs.data());
eval_L1001(m_molefracs.data());
eval_L0100();
eval_L0110();
eval_L0101(DATA_PTR(m_molefracs));
eval_L0101(m_molefracs.data());
// Solve it using GMRES or LU decomposition. The last solution
// in m_a should provide a good starting guess, so convergence
// should be fast.
copy(m_b.begin(), m_b.end(), m_a.begin());
try {
solve(m_Lmatrix, DATA_PTR(m_a));
solve(m_Lmatrix, m_a.data());
} catch (CanteraError& err) {
err.save();
throw CanteraError("MultiTransport::solveLMatrixEquation",
@ -192,7 +192,7 @@ void MultiTransport::getSpeciesFluxes(size_t ndim, const doublereal* const grad_
}
}
if (addThermalDiffusion) {
getThermalDiffCoeffs(DATA_PTR(m_spwork));
getThermalDiffCoeffs(m_spwork.data());
}
const doublereal* y = m_thermo->massFractions();
@ -277,9 +277,9 @@ void MultiTransport::getSpeciesFluxes(size_t ndim, const doublereal* const grad_
void MultiTransport::getMassFluxes(const doublereal* state1, const doublereal* state2, doublereal delta,
doublereal* fluxes)
{
double* x1 = DATA_PTR(m_spwork1);
double* x2 = DATA_PTR(m_spwork2);
double* x3 = DATA_PTR(m_spwork3);
double* x1 = m_spwork1.data();
double* x2 = m_spwork2.data();
double* x3 = m_spwork3.data();
size_t n, nsp = m_thermo->nSpecies();
m_thermo->restoreState(nsp+2, state1);
double p1 = m_thermo->pressure();
@ -298,7 +298,7 @@ void MultiTransport::getMassFluxes(const doublereal* state1, const doublereal* s
x3[n] = 0.5*(x1[n] + x2[n]);
}
m_thermo->setState_TPX(t, p, x3);
m_thermo->getMoleFractions(DATA_PTR(m_molefracs));
m_thermo->getMoleFractions(m_molefracs.data());
// update the binary diffusion coefficients if necessary
update_T();
@ -309,7 +309,7 @@ void MultiTransport::getMassFluxes(const doublereal* state1, const doublereal* s
bool addThermalDiffusion = false;
if (state1[0] != state2[0]) {
addThermalDiffusion = true;
getThermalDiffCoeffs(DATA_PTR(m_spwork));
getThermalDiffCoeffs(m_spwork.data());
}
const doublereal* y = m_thermo->massFractions();
@ -396,7 +396,7 @@ void MultiTransport::getMultiDiffCoeffs(const size_t ld, doublereal* const d)
// evaluate L0000 if the temperature or concentrations have
// changed since it was last evaluated.
if (!m_l0000_ok) {
eval_L0000(DATA_PTR(m_molefracs));
eval_L0000(m_molefracs.data());
}
// invert L00,00
@ -436,7 +436,7 @@ void MultiTransport::update_T()
void MultiTransport::update_C()
{
// Update the local mole fraction array
m_thermo->getMoleFractions(DATA_PTR(m_molefracs));
m_thermo->getMoleFractions(m_molefracs.data());
for (size_t k = 0; k < m_nsp; k++) {
// add an offset to avoid a pure species condition
@ -467,15 +467,15 @@ void MultiTransport::updateThermal_T()
z = m_logt - m_log_eps_k(i,j);
ipoly = m_poly[i][j];
if (m_mode == CK_Mode) {
m_om22(i,j) = poly6(z, DATA_PTR(m_omega22_poly[ipoly]));
m_astar(i,j) = poly6(z, DATA_PTR(m_astar_poly[ipoly]));
m_bstar(i,j) = poly6(z, DATA_PTR(m_bstar_poly[ipoly]));
m_cstar(i,j) = poly6(z, DATA_PTR(m_cstar_poly[ipoly]));
m_om22(i,j) = poly6(z, m_omega22_poly[ipoly].data());
m_astar(i,j) = poly6(z, m_astar_poly[ipoly].data());
m_bstar(i,j) = poly6(z, m_bstar_poly[ipoly].data());
m_cstar(i,j) = poly6(z, m_cstar_poly[ipoly].data());
} else {
m_om22(i,j) = poly8(z, DATA_PTR(m_omega22_poly[ipoly]));
m_astar(i,j) = poly8(z, DATA_PTR(m_astar_poly[ipoly]));
m_bstar(i,j) = poly8(z, DATA_PTR(m_bstar_poly[ipoly]));
m_cstar(i,j) = poly8(z, DATA_PTR(m_cstar_poly[ipoly]));
m_om22(i,j) = poly8(z, m_omega22_poly[ipoly].data());
m_astar(i,j) = poly8(z, m_astar_poly[ipoly].data());
m_bstar(i,j) = poly8(z, m_bstar_poly[ipoly].data());
m_cstar(i,j) = poly8(z, m_cstar_poly[ipoly].data());
}
m_om22(j,i) = m_om22(i,j);
m_astar(j,i) = m_astar(i,j);

14
src/transport/SimpleTransport.cpp
View file

@ -310,7 +310,7 @@ void SimpleTransport::getBinaryDiffCoeffs(size_t ld, doublereal* d)
void SimpleTransport::getMobilities(doublereal* const mobil)
{
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
doublereal c1 = ElectronCharge / (Boltzmann * m_temp);
for (size_t k = 0; k < m_nsp; k++) {
mobil[k] = c1 * m_spwork[k];
@ -319,7 +319,7 @@ void SimpleTransport::getMobilities(doublereal* const mobil)
void SimpleTransport::getFluidMobilities(doublereal* const mobil_f)
{
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
doublereal c1 = 1.0 / (GasConstant * m_temp);
for (size_t k = 0; k < m_nsp; k++) {
mobil_f[k] = c1 * m_spwork[k];
@ -394,7 +394,7 @@ void SimpleTransport::getSpeciesVdiff(size_t ndim,
set_Grad_X(grad_X);
const doublereal* y = m_thermo->massFractions();
const doublereal rho = m_thermo->density();
getSpeciesFluxesExt(m_nsp, DATA_PTR(Vdiff));
getSpeciesFluxesExt(m_nsp, Vdiff);
for (size_t n = 0; n < m_nDim; n++) {
for (size_t k = 0; k < m_nsp; k++) {
if (y[k] > 1.0E-200) {
@ -416,7 +416,7 @@ void SimpleTransport::getSpeciesVdiffES(size_t ndim, const doublereal* grad_T,
set_Grad_V(grad_Phi);
const doublereal* y = m_thermo->massFractions();
const doublereal rho = m_thermo->density();
getSpeciesFluxesExt(m_nsp, DATA_PTR(Vdiff));
getSpeciesFluxesExt(m_nsp, Vdiff);
for (size_t n = 0; n < m_nDim; n++) {
for (size_t k = 0; k < m_nsp; k++) {
if (y[k] > 1.0E-200) {
@ -443,7 +443,7 @@ void SimpleTransport::getSpeciesFluxesExt(size_t ldf, doublereal* fluxes)
update_T();
update_C();
getMixDiffCoeffs(DATA_PTR(m_spwork));
getMixDiffCoeffs(m_spwork.data());
const vector_fp& mw = m_thermo->molecularWeights();
const doublereal* y = m_thermo->massFractions();
@ -539,8 +539,8 @@ bool SimpleTransport::update_C()
int iStateNew = m_thermo->stateMFNumber();
if (iStateNew != m_iStateMF) {
qReturn = false;
m_thermo->getMoleFractions(DATA_PTR(m_molefracs));
m_thermo->getConcentrations(DATA_PTR(m_concentrations));
m_thermo->getMoleFractions(m_molefracs.data());
m_thermo->getConcentrations(m_concentrations.data());
concTot_ = 0.0;
for (size_t k = 0; k < m_nsp; k++) {
m_molefracs[k] = std::max(0.0, m_molefracs[k]);

2
src/zeroD/FlowReactor.cpp
View file

@ -92,7 +92,7 @@ void FlowReactor::evalEqs(doublereal time, doublereal* y,
ydot[1] = m_fctr*(m_speed0 - m_thermo->density()*m_speed/m_rho0);
/* species equations */
const doublereal* mw = DATA_PTR(m_thermo->molecularWeights());
const vector_fp& mw = m_thermo->molecularWeights();
if (m_chem) {
m_kin->getNetProductionRates(ydot+2); // "omega dot"

4
src/zeroD/ReactorNet.cpp
View file

@ -69,7 +69,7 @@ void ReactorNet::initialize()
m_ydot.resize(m_nv,0.0);
m_atol.resize(neq());
fill(m_atol.begin(), m_atol.end(), m_atols);
m_integ->setTolerances(m_rtol, neq(), DATA_PTR(m_atol));
m_integ->setTolerances(m_rtol, neq(), m_atol.data());
m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens);
m_integ->setMaxStepSize(m_maxstep);
m_integ->setMaxErrTestFails(m_maxErrTestFails);
@ -157,7 +157,7 @@ void ReactorNet::evalJacobian(doublereal t, doublereal* y,
dy = y[n] - ysave;
// calculate perturbed residual
eval(t, y, DATA_PTR(m_ydot), p);
eval(t, y, m_ydot.data(), p);
// compute nth column of Jacobian
for (size_t m = 0; m < m_nv; m++) {

8
src/zeroD/Wall.cpp
View file

@ -48,7 +48,7 @@ void Wall::setKinetics(Kinetics* left, Kinetics* right)
m_surf[0] = (SurfPhase*)&left->thermo(ileft);
m_nsp[0] = m_surf[0]->nSpecies();
m_leftcov.resize(m_nsp[0]);
m_surf[0]->getCoverages(DATA_PTR(m_leftcov));
m_surf[0]->getCoverages(m_leftcov.data());
}
}
if (right) {
@ -57,7 +57,7 @@ void Wall::setKinetics(Kinetics* left, Kinetics* right)
m_surf[1] = (SurfPhase*)&right->thermo(iright);
m_nsp[1] = m_surf[1]->nSpecies();
m_rightcov.resize(m_nsp[1]);
m_surf[1]->getCoverages(DATA_PTR(m_rightcov));
m_surf[1]->getCoverages(m_rightcov.data());
}
}
if (ileft == npos || iright == npos) {
@ -133,9 +133,9 @@ void Wall::getCoverages(int leftright, doublereal* cov)
void Wall::syncCoverages(int leftright)
{
if (leftright == 0) {
m_surf[0]->setCoverages(DATA_PTR(m_leftcov));
m_surf[0]->setCoverages(m_leftcov.data());
} else {
m_surf[1]->setCoverages(DATA_PTR(m_rightcov));
m_surf[1]->setCoverages(m_rightcov.data());
}
}

2
test_problems/ChemEquil_ionizedGas/ionizedGasEquil.cpp
View file

@ -64,7 +64,7 @@ int main(int argc, char** argv)
cout << "heat capacity c_p = " << gas->cp_mass() << endl;
cout << "heat capacity c_v = " << gas->cv_mass() << endl << endl;
gas->getMoleFractions(DATA_PTR(Xmol));
gas->getMoleFractions(Xmol.data());
fprintf(FF,"%10.4g, %10.4g,", tkelvin, pres);
for (size_t k = 0; k < kk; k++) {
if (fabs(Xmol[k]) < 1.0E-130) {

4
test_problems/VCSnonideal/NaCl_equil/nacl_equil.cpp
View file

@ -91,7 +91,7 @@ int main(int argc, char** argv)
vector_fp Xmol(kk, 0.0);
size_t iH2OL = hmw.speciesIndex("H2O(L)");
Xmol[iH2OL] = 1.0;
hmw.setState_TPX(T, pres, DATA_PTR(Xmol));
hmw.setState_TPX(T, pres, Xmol.data());
ThermoPhase* gas = newPhase("gas.xml");
@ -102,7 +102,7 @@ int main(int argc, char** argv)
}
size_t iN2 = gas->speciesIndex("N2");
Xmol[iN2] = 1.0;
gas->setState_TPX(T, pres, DATA_PTR(Xmol));
gas->setState_TPX(T, pres, Xmol.data());
StoichSubstanceSSTP ss("NaCl_Solid.xml", "");

2
test_problems/dustyGasTransport/dustyGasTransportTest.cpp
View file

@ -28,7 +28,7 @@ int main(int argc, char** argv)
tranDusty->setMeanPoreRadius(1.5E-7);
tranDusty->setMeanParticleDiameter(1.5E-6);
tranDusty->getMultiDiffCoeffs(nsp, DATA_PTR(multiD));
tranDusty->getMultiDiffCoeffs(nsp, multiD.data());
printf("MultiDiffusion coefficients: \n");
for (size_t i = 0; i < nsp; i++) {
for (size_t j = 0; j < nsp; j++) {

16
test_problems/mixGasTransport/mixGasTransport.cpp
View file

@ -131,11 +131,11 @@ int main(int argc, char** argv)
int log_level = 0;
Transport* tran = newTransportMgr("Mix", &g, log_level=0);
MixTransport* tranMix = dynamic_cast<MixTransport*>(tran);
g.setState_TPX(1500.0, pres, DATA_PTR(Xset));
g.setState_TPX(1500.0, pres, Xset.data());
vector_fp mixDiffs(nsp, 0.0);
tranMix->getMixDiffCoeffs(DATA_PTR(mixDiffs));
tranMix->getMixDiffCoeffs(mixDiffs.data());
printf(" Dump of the mixture Diffusivities:\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -144,7 +144,7 @@ int main(int argc, char** argv)
vector_fp specVisc(nsp, 0.0);
tranMix->getSpeciesViscosities(DATA_PTR(specVisc));
tranMix->getSpeciesViscosities(specVisc.data());
printf(" Dump of the species viscosities:\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -152,7 +152,7 @@ int main(int argc, char** argv)
}
vector_fp thermDiff(nsp, 0.0);
tranMix->getThermalDiffCoeffs(DATA_PTR(thermDiff));
tranMix->getThermalDiffCoeffs(thermDiff.data());
printf(" Dump of the Thermal Diffusivities :\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -162,13 +162,13 @@ int main(int argc, char** argv)
printf("Viscosity and thermal Cond vs. T\n");
for (size_t k = 0; k < 10; k++) {
T1 = 400. + 100. * k;
g.setState_TPX(T1, pres, DATA_PTR(Xset));
g.setState_TPX(T1, pres, Xset.data());
double visc = tran->viscosity();
double cond = tran->thermalConductivity();
printf(" %13.4g %13.4g %13.4g\n", T1, visc, cond);
}
g.setState_TPX(T1, pres, DATA_PTR(Xset));
g.setState_TPX(T1, pres, Xset.data());
Array2D Bdiff(nsp, nsp, 0.0);
printf("Binary Diffusion Coefficients H2 vs species\n");
@ -182,7 +182,7 @@ int main(int argc, char** argv)
vector_fp specMob(nsp, 0.0);
tranMix->getMobilities(DATA_PTR(specMob));
tranMix->getMobilities(specMob.data());
printf(" Dump of the species mobilities:\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -191,7 +191,7 @@ int main(int argc, char** argv)
Array2D fluxes(nsp, 2, 0.0);
tranMix->getSpeciesFluxes(2, DATA_PTR(grad_T), nsp,
tranMix->getSpeciesFluxes(2, grad_T.data(), nsp,
grad_X.ptrColumn(0), nsp, fluxes.ptrColumn(0));
printf(" Dump of the species fluxes:\n");
double sum1 = 0.0;

14
test_problems/multiGasTransport/multiGasTransport.cpp
View file

@ -141,10 +141,10 @@ int main(int argc, char** argv)
int log_level = 0;
Transport* tran = newTransportMgr("Multi", &g, log_level=0);
MultiTransport* tranMix = dynamic_cast<MultiTransport*>(tran);
g.setState_TPX(1500.0, pres, DATA_PTR(Xset));
g.setState_TPX(1500.0, pres, Xset.data());
vector_fp mixDiffs(nsp, 0.0);
tranMix->getMixDiffCoeffs(DATA_PTR(mixDiffs));
tranMix->getMixDiffCoeffs(mixDiffs.data());
printf(" Dump of the mixture Diffusivities:\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -152,7 +152,7 @@ int main(int argc, char** argv)
}
vector_fp specVisc(nsp, 0.0);
tranMix->getSpeciesViscosities(DATA_PTR(specVisc));
tranMix->getSpeciesViscosities(specVisc.data());
printf(" Dump of the species viscosities:\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -160,7 +160,7 @@ int main(int argc, char** argv)
}
vector_fp thermDiff(nsp, 0.0);
tranMix->getThermalDiffCoeffs(DATA_PTR(thermDiff));
tranMix->getThermalDiffCoeffs(thermDiff.data());
printf(" Dump of the Thermal Diffusivities :\n");
for (size_t k = 0; k < nsp; k++) {
string sss = g.speciesName(k);
@ -171,13 +171,13 @@ int main(int argc, char** argv)
printf("Viscosity and thermal Cond vs. T\n");
for (size_t k = 0; k < 10; k++) {
T1 = 400. + 100. * k;
g.setState_TPX(T1, pres, DATA_PTR(Xset));
g.setState_TPX(T1, pres, Xset.data());
double visc = tran->viscosity();
double cond = tran->thermalConductivity();
printf(" %13g %13.4g %13.4g\n", T1, visc, cond);
}
g.setState_TPX(T1, pres, DATA_PTR(Xset));
g.setState_TPX(T1, pres, Xset.data());
Array2D Bdiff(nsp, nsp, 0.0);
printf("Binary Diffusion Coefficients H2 vs species\n");
@ -197,7 +197,7 @@ int main(int argc, char** argv)
}
Array2D fluxes(nsp, 2, 0.0);
tranMix->getSpeciesFluxes(2, DATA_PTR(grad_T), nsp,
tranMix->getSpeciesFluxes(2, grad_T.data(), nsp,
grad_X.ptrColumn(0), nsp, fluxes.ptrColumn(0));
printf(" Dump of the species fluxes:\n");
double sum1 = 0.0;

5
test_problems/surfkin/surfdemo.cpp
View file

@ -20,9 +20,9 @@ int main()
Interface surf("surface.xml", "surface", phases);
vector_fp cov { 0.8, 0.2 };
cout.precision(4);
surf.setCoverages(DATA_PTR(cov));
surf.setCoverages(cov.data());
vector_fp wdot(gas.nSpecies() + surf.nSpecies());
surf.getNetProductionRates(DATA_PTR(wdot));
surf.getNetProductionRates(wdot.data());
for (size_t k = 0; k < gas.nSpecies(); k++) {
cout << gas.speciesName(k) << " " << wdot[k] << endl;
}
@ -36,4 +36,3 @@ int main()
}
return 0;
}