GasFlowMeter/User/NG/AGA10.c

#include "aga10.h"
#include "detail.h"
#include <math.h>

Detail::Detail(void)
{
dOldMixID = 0.0;
dOldPb = 0.0;
dOldTb = 0.0;
dOldPf = 0.0;
dOldTf = 0.0;

for (int i=0 ;i<NUMBEROFCOMPONENTS ;i++)
dXi[i] = 0;

table();
}

Detail::~Detail()
{
}

bool Detail::compositionchange(AGA10STRUCT *ptAGA10)
{
double dMixID = 0.0;
int i;

for (i=0; i<NUMBEROFCOMPONENTS; i++)
dMixID += ((i+2) * ptAGA10->adMixture[i]);

if (dMixID != dOldMixID)
{
dOldMixID = dMixID;
return true;
}
else
{
return false;
}
}

void Detail::Run(AGA10STRUCT *ptAGA10)
{
int i;

ptAGA10->bForceUpdate = (ptAGA10->bForceUpdate || compositionchange(ptAGA10));

if (ptAGA10->bForceUpdate)
{
iNCC = -1;
for (i=0; i<NUMBEROFCOMPONENTS; i++)
{
if (ptAGA10->adMixture[i] > 0.0)
{
iNCC = iNCC + 1;
aiCID[iNCC] = i;
dXi[iNCC] = ptAGA10->adMixture[i];
}
}
iNCC = iNCC +1;

paramdl();
chardl(ptAGA10);
}

if ((fabs(ptAGA10->dPb - dOldPb) > P_CHG_TOL)|| (fabs(ptAGA10->dTb - dOldTb) > T_CHG_TOL)|| (ptAGA10->bForceUpdate))
{
dP = ptAGA10->dPb * 1.0e-6;
dT = ptAGA10->dTb;

temp();
ddetail(ptAGA10);
ptAGA10->dDb = dRho;

ptAGA10->dZb = zdetail(dRho);

dRhoTP = (dP * ptAGA10->dMrx) / (ptAGA10->dZb * RGASKJ * dT);

relativedensity(ptAGA10);

ptAGA10->dRhob = dRhoTP;

dOldTb = ptAGA10->dTb;
dOldPb = ptAGA10->dPb;
ptAGA10->bForceUpdate = true;
}

dP = ptAGA10->dPf * 1.0e-6;
dT = ptAGA10->dTf;

if ((fabs(ptAGA10->dTf - dOldTf) > T_CHG_TOL)||(ptAGA10->bForceUpdate))
{
temp();
ptAGA10->bForceUpdate = true;
}

if ((fabs(ptAGA10->dPf - dOldPf) > P_CHG_TOL)||(ptAGA10->bForceUpdate))
{
ddetail(ptAGA10);
ptAGA10->dDf = dRho;

ptAGA10->dZf = zdetail(dRho);

dRhoTP = (dP * ptAGA10->dMrx) / (ptAGA10->dZf * RGASKJ * dT);
ptAGA10->dRhof = dRhoTP;

dOldTf = ptAGA10->dTf;
dOldPf = ptAGA10->dPf;
}

if ((ptAGA10->dZb > 0.0) && (ptAGA10->dZf > 0.0))
{
ptAGA10->dFpv = sqrt(ptAGA10->dZb / ptAGA10->dZf);
}
else
{
ptAGA10->dFpv = ptAGA10->dZb = ptAGA10->dZf = 0.0;
ptAGA10->lStatus = GENERAL_CALCULATION_FAILURE;
}

ptAGA10->bForceUpdate = false;
}

void Detail::table(void)
{
int j, k;

adAn[0] = 0.153832600;
adAn[1] = 1.341953000;
adAn[2] = -2.998583000;
adAn[3] = -0.048312280;
adAn[4] = 0.375796500;
adAn[5] = -1.589575000;
adAn[6] = -0.053588470;
adAn[7] = 0.886594630;
adAn[8] = -0.710237040;
adAn[9] = -1.471722000;
adAn[10] = 1.321850350;
adAn[11] = -0.786659250;
adAn[12] = 2.29129E-09;
adAn[13] = 0.157672400;
adAn[14] = -0.436386400;
adAn[15] = -0.044081590;
adAn[16] = -0.003433888;
adAn[17] = 0.032059050;
adAn[18] = 0.024873550;
adAn[19] = 0.073322790;
adAn[20] = -0.001600573;
adAn[21] = 0.642470600;
adAn[22] = -0.416260100;
adAn[23] = -0.066899570;
adAn[24] = 0.279179500;
adAn[25] = -0.696605100;
adAn[26] = -0.002860589;
adAn[27] = -0.008098836;
adAn[28] = 3.150547000;
adAn[29] = 0.007224479;
adAn[30] = -0.705752900;
adAn[31] = 0.534979200;
adAn[32] = -0.079314910;
adAn[33] = -1.418465000;
adAn[34] = -5.99905E-17;
adAn[35] = 0.105840200;
adAn[36] = 0.034317290;
adAn[37] = -0.007022847;
adAn[38] = 0.024955870;
adAn[39] = 0.042968180;
adAn[40] = 0.746545300;
adAn[41] = -0.291961300;
adAn[42] = 7.294616000;
adAn[43] = -9.936757000;
adAn[44] = -0.005399808;
adAn[45] = -0.243256700;
adAn[46] = 0.049870160;
adAn[47] = 0.003733797;
adAn[48] = 1.874951000;
adAn[49] = 0.002168144;
adAn[50] = -0.658716400;
adAn[51] = 0.000205518;
adAn[52] = 0.009776195;
adAn[53] = -0.020487080;
adAn[54] = 0.015573220;
adAn[55] = 0.006862415;
adAn[56] = -0.001226752;
adAn[57] = 0.002850908;

adUn[0] = 0.0;
adUn[1] = 0.5;
adUn[2] = 1.0;
adUn[3] = 3.5;
adUn[4] = -0.5;
adUn[5] = 4.5;
adUn[6] = 0.5;
adUn[7] = 7.5;
adUn[8] = 9.5;
adUn[9] = 6.0;
adUn[10] = 12.0;
adUn[11] = 12.5;
adUn[12] = -6.0;
adUn[13] = 2.0;
adUn[14] = 3.0;
adUn[15] = 2.0;
adUn[16] = 2.0;
adUn[17] = 11.0;
adUn[18] = -0.5;
adUn[19] = 0.5;
adUn[20] = 0.0;
adUn[21] = 4.0;
adUn[22] = 6.0;
adUn[23] = 21.0;
adUn[24] = 23.0;
adUn[25] = 22.0;
adUn[26] = -1.0;
adUn[27] = -0.5;
adUn[28] = 7.0;
adUn[29] = -1.0;
adUn[30] = 6.0;
adUn[31] = 4.0;
adUn[32] = 1.0;
adUn[33] = 9.0;
adUn[34] = -13.0;
adUn[35] = 21.0;
adUn[36] = 8.0;
adUn[37] = -0.5;
adUn[38] = 0.0;
adUn[39] = 2.0;
adUn[40] = 7.0;
adUn[41] = 9.0;
adUn[42] = 22.0;
adUn[43] = 23.0;
adUn[44] = 1.0;
adUn[45] = 9.0;
adUn[46] = 3.0;
adUn[47] = 8.0;
adUn[48] = 23.0;
adUn[49] = 1.5;
adUn[50] = 5.0;
adUn[51] = -0.5;
adUn[52] = 4.0;
adUn[53] = 7.0;
adUn[54] = 3.0;
adUn[55] = 0.0;
adUn[56] = 1.0;
adUn[57] = 0.0;

for (j=0; j < NUMBEROFCOMPONENTS; j++)
{
for (k=j; k < NUMBEROFCOMPONENTS; k++)
{
adTable6Eij[j][k] = 1.0;
adTable6Uij[j][k] = 1.0;
adTable6Kij[j][k] = 1.0;
adTable6Gij[j][k] = 1.0;
}
}

adTable6Eij[0][1] = 0.971640;
adTable6Eij[0][2] = 0.960644;
adTable6Eij[0][4] = 0.994635;
adTable6Eij[0][5] = 0.708218;
adTable6Eij[0][6] = 0.931484;
adTable6Eij[0][7] = 1.170520;
adTable6Eij[0][8] = 0.990126;
adTable6Eij[0][10] = 1.019530;
adTable6Eij[0][11] = 0.989844;
adTable6Eij[0][12] = 1.002350;
adTable6Eij[0][13] = 0.999268;
adTable6Eij[0][14] = 1.107274;
adTable6Eij[0][15] = 0.880880;
adTable6Eij[0][16] = 0.880973;
adTable6Eij[0][17] = 0.881067;
adTable6Eij[0][18] = 0.881161;
adTable6Eij[1][2] = 1.022740;
adTable6Eij[1][3] = 0.970120;
adTable6Eij[1][4] = 0.945939;
adTable6Eij[1][5] = 0.746954;
adTable6Eij[1][6] = 0.902271;
adTable6Eij[1][7] = 1.086320;
adTable6Eij[1][8] = 1.005710;
adTable6Eij[1][9] = 1.021000;
adTable6Eij[1][10] = 0.946914;
adTable6Eij[1][11] = 0.973384;
adTable6Eij[1][12] = 0.959340;
adTable6Eij[1][13] = 0.945520;
adTable6Eij[2][3] = 0.925053;
adTable6Eij[2][4] = 0.960237;
adTable6Eij[2][5] = 0.849408;
adTable6Eij[2][6] = 0.955052;
adTable6Eij[2][7] = 1.281790;
adTable6Eij[2][8] = 1.500000;
adTable6Eij[2][10] = 0.906849;
adTable6Eij[2][11] = 0.897362;
adTable6Eij[2][12] = 0.726255;
adTable6Eij[2][13] = 0.859764;
adTable6Eij[2][14] = 0.855134;
adTable6Eij[2][15] = 0.831229;
adTable6Eij[2][16] = 0.808310;
adTable6Eij[2][17] = 0.786323;
adTable6Eij[2][18] = 0.765171;
adTable6Eij[3][4] = 1.022560;
adTable6Eij[3][5] = 0.693168;
adTable6Eij[3][6] = 0.946871;
adTable6Eij[3][7] = 1.164460;
adTable6Eij[3][11] = 1.013060;
adTable6Eij[3][13] = 1.005320;
adTable6Eij[4][7] = 1.034787;
adTable6Eij[4][11] = 1.004900;
adTable6Eij[6][14] = 1.008692;
adTable6Eij[6][15] = 1.010126;
adTable6Eij[6][16] = 1.011501;
adTable6Eij[6][17] = 1.012821;
adTable6Eij[6][18] = 1.014089;
adTable6Eij[7][8] = 1.100000;
adTable6Eij[7][10] = 1.300000;
adTable6Eij[7][11] = 1.300000;
adTable6Uij[0][1] = 0.886106;
adTable6Uij[0][2] = 0.963827;
adTable6Uij[0][4] = 0.990877;
adTable6Uij[0][6] = 0.736833;
adTable6Uij[0][7] = 1.156390;
adTable6Uij[0][11] = 0.992291;
adTable6Uij[0][13] = 1.003670;
adTable6Uij[0][14] = 1.302576;
adTable6Uij[0][15] = 1.191904;
adTable6Uij[0][16] = 1.205769;
adTable6Uij[0][17] = 1.219634;
adTable6Uij[0][18] = 1.233498;
adTable6Uij[1][2] = 0.835058;
adTable6Uij[1][3] = 0.816431;
adTable6Uij[1][4] = 0.915502;
adTable6Uij[1][6] = 0.993476;
adTable6Uij[1][7] = 0.408838;
adTable6Uij[1][11] = 0.993556;
adTable6Uij[2][3] = 0.969870;
adTable6Uij[2][6] = 1.045290;
adTable6Uij[2][8] = 0.900000;
adTable6Uij[2][14] = 1.066638;
adTable6Uij[2][15] = 1.077634;
adTable6Uij[2][16] = 1.088178;
adTable6Uij[2][17] = 1.098291;
adTable6Uij[2][18] = 1.108021;
adTable6Uij[3][4] = 1.065173;
adTable6Uij[3][6] = 0.971926;
adTable6Uij[3][7] = 1.616660;
adTable6Uij[3][10] = 1.250000;
adTable6Uij[3][11] = 1.250000;
adTable6Uij[3][12] = 1.250000;
adTable6Uij[3][13] = 1.250000;
adTable6Uij[6][14] = 1.028973;
adTable6Uij[6][15] = 1.033754;
adTable6Uij[6][16] = 1.038338;
adTable6Uij[6][17] = 1.042735;
adTable6Uij[6][18] = 1.046966;
adTable6Kij[0][1] = 1.003630;
adTable6Kij[0][2] = 0.995933;
adTable6Kij[0][4] = 1.007619;
adTable6Kij[0][6] = 1.000080;
adTable6Kij[0][7] = 1.023260;
adTable6Kij[0][11] = 0.997596;
adTable6Kij[0][13] = 1.002529;
adTable6Kij[0][14] = 0.982962;
adTable6Kij[0][15] = 0.983565;
adTable6Kij[0][16] = 0.982707;
adTable6Kij[0][17] = 0.981849;
adTable6Kij[0][18] = 0.980991;
adTable6Kij[1][2] = 0.982361;
adTable6Kij[1][3] = 1.007960;
adTable6Kij[1][6] = 0.942596;
adTable6Kij[1][7] = 1.032270;
adTable6Kij[2][3] = 1.008510;
adTable6Kij[2][6] = 1.007790;
adTable6Kij[2][14] = 0.910183;
adTable6Kij[2][15] = 0.895362;
adTable6Kij[2][16] = 0.881152;
adTable6Kij[2][17] = 0.867520;
adTable6Kij[2][18] = 0.854406;
adTable6Kij[3][4] = 0.986893;
adTable6Kij[3][6] = 0.999969;
adTable6Kij[3][7] = 1.020340;
adTable6Kij[6][14] = 0.968130;
adTable6Kij[6][15] = 0.962870;
adTable6Kij[6][16] = 0.957828;
adTable6Kij[6][17] = 0.952441;
adTable6Kij[6][18] = 0.948338;
adTable6Gij[0][2] = 0.807653;
adTable6Gij[0][7] = 1.957310;
adTable6Gij[1][2] = 0.982746;
adTable6Gij[2][3] = 0.370296;
adTable6Gij[2][5] = 1.673090;
}

void Detail::paramdl(void)
{
int j, k;

const double adTable5Mri[NUMBEROFCOMPONENTS] = {16.0430, 28.0135, 44.0100, 30.0700, 44.0970, 18.0153, 34.0820, 2.0159, 28.0100, 31.9988, 58.1230, 58.1230, 72.1500, 72.1500, 86.1770, 100.2040,114.2310,128.2580,142.2850,4.0026, 39.9480};

const double adTable5Ei[NUMBEROFCOMPONENTS] = {151.318300, 99.737780, 241.960600, 244.166700, 298.118300, 514.015600, 296.355000, 26.957940, 105.534800, 122.766700, 324.068900, 337.638900, 365.599900, 370.682300, 402.636293, 427.722630, 450.325022, 470.840891, 489.558373, 2.610111, 119.629900};

const double adTable5Ki[NUMBEROFCOMPONENTS] = {0.4619255, 0.4479153, 0.4557489, 0.5279209, 0.5837490, 0.3825868, 0.4618263, 0.3514916, 0.4533894, 0.4186954, 0.6406937, 0.6341423, 0.6738577, 0.6798307, 0.7175118, 0.7525189, 0.7849550, 0.8152731, 0.8437826, 0.3589888, 0.4216551};

const double adTable5Gi[NUMBEROFCOMPONENTS] = {0.000000,0.027815,0.189065,0.079300,0.141239, 0.332500,0.088500,0.034369,0.038953,0.021000, 0.256692,0.281835,0.332267,0.366911,0.289731, 0.337542,0.383381,0.427354,0.469659,0.000000, 0.000000};

for (j=0; j < NUMBEROFCOMPONENTS; j++)
{
adTable5Qi[j] = 0.0;
adTable5Fi[j] = 0.0;
adTable5Si[j] = 0.0;
adTable5Wi[j] = 0.0;
}

adTable5Qi[2] = 0.690000;
adTable5Qi[5] = 1.067750;
adTable5Qi[6] = 0.633276;

adTable5Fi[7] = 1.0000;

adTable5Si[5] = 1.5822;
adTable5Si[6] = 0.3900;

adTable5Wi[5] = 1.0000;

for (j=iNCC-1; j >= 0; j--)
{
dMri[j] = adTable5Mri[aiCID[j]];
dKi[j] = adTable5Ki[aiCID[j]];
}

for (j=0; j < iNCC; j++)
{
dGi[j] = adTable5Gi[aiCID[j]];
dEi[j] = adTable5Ei[aiCID[j]];
}

for (j=0; j < iNCC; j++)
{
dQi[j] = adTable5Qi[aiCID[j]];
dFi[j] = 0.0;

if (aiCID[j] == 7) dFi[j] = adTable5Fi[7];
dSi[j] = adTable5Si[aiCID[j]];

dWi[j] = adTable5Wi[aiCID[j]];
}

for (j=0; j < iNCC; j++)
{
for (k=j; k < iNCC; k++)
{
dUij[j][k] = adTable6Uij[aiCID[j]][aiCID[k]];
dKij[j][k] = adTable6Kij[aiCID[j]][aiCID[k]];
dEij[j][k] = adTable6Eij[aiCID[j]][aiCID[k]];
dGij[j][k] = adTable6Gij[aiCID[j]][aiCID[k]];
}
}
}

void Detail::chardl(AGA10STRUCT *ptAGA10)
{
int i,j;

double tmfrac, k5p0, k2p5, u5p0, u2p5, q1p0;
double Xij, Eij, Gij, e0p5, e2p0, e3p0, e3p5, e4p5, e6p0;
double e7p5,e9p5,e12p0,e12p5;
double e11p0, s3;

tmfrac = 0.0;

for (j=0; j < iNCC; j++)
{
tmfrac = tmfrac + dXi[j];
}

for (j=0; j < iNCC; j++)
{
dXi[j] = dXi[j]/tmfrac;
}

for (j=0; j < 18; j++)
{
adBcoef[j] = 0.0;
}

k5p0 = 0.0;
k2p5 = 0.0;
u5p0 = 0.0;
u2p5 = 0.0;
dW = 0.0;
q1p0 = 0.0;
dF = 0.0;

ptAGA10->dMrx = 0.0;

for (j=0; j < iNCC; j++)
{
ptAGA10->dMrx = ptAGA10->dMrx + dXi[j] * dMri[j];
}

for (i=0; i < iNCC; i++)
{
k2p5 = k2p5 + dXi[i] * dKi[i] * dKi[i] * sqrt(dKi[i]);
u2p5 = u2p5 + dXi[i] * dEi[i] * dEi[i] * sqrt(dEi[i]);
dW = dW + dXi[i] * dGi[i];
q1p0 = q1p0 + dXi[i] * dQi[i];
dF = dF + dXi[i] * dXi[i] * dFi[i];

for (j=i; j < iNCC; j++)
{
if (i != j) Xij = 2.0 * dXi[i] * dXi[j];
else Xij = dXi[i] * dXi[j];

if (dKij[i][j] != 1.0)
k5p0 += Xij * (pow(dKij[i][j],5.0) - 1.0) * pow((pow(dKi[i],5.0) * pow(dKi[j],5.0)),0.5);

if (dUij[i][j] != 1.0)
u5p0 += Xij * (pow(dUij[i][j],5.0) - 1.0) * pow((pow(dEi[i],5.0) * pow(dEi[j],5.0)),0.5);

if (dGij[i][j] != 1.0)
dW += Xij * (dGij[i][j] - 1.0) * ((dGi[i] + dGi[j]) / 2.0);

Eij = dEij[i][j] * sqrt(dEi[i] * dEi[j]);

Gij = dGij[i][j] * (dGi[i] + dGi[j]) / 2.0;

e0p5 = sqrt(Eij);
e2p0 = Eij * Eij;
e3p0 = Eij * e2p0;
e3p5 = e3p0 * e0p5;
e4p5 = Eij * e3p5;
e6p0 = e3p0 * e3p0;
e11p0= e4p5 * e4p5 * e2p0;
e7p5 = e4p5 * Eij * e2p0;
e9p5 = e7p5 * e2p0;
e12p0= e11p0 * Eij;
e12p5= e12p0 * e0p5;

s3 = Xij * pow((pow(dKi[i], 3.0) * pow(dKi[j],3)), 0.5);

adBcoef[0] = adBcoef[0] + s3;
adBcoef[1] = adBcoef[1] + s3 * e0p5;
adBcoef[2] = adBcoef[2] + s3 * Eij;
adBcoef[3] = adBcoef[3] + s3 * e3p5;
adBcoef[4] = adBcoef[4] + s3 * Gij / e0p5;
adBcoef[5] = adBcoef[5] + s3 * Gij * e4p5;
adBcoef[6] = adBcoef[6] + s3 * dQi[i] * dQi[j] * e0p5;
adBcoef[7] = adBcoef[7] + s3 * dSi[i] * dSi[j] * e7p5;
adBcoef[8] = adBcoef[8] + s3 * dSi[i] * dSi[j] * e9p5;
adBcoef[9] = adBcoef[9] + s3 * dWi[i] * dWi[j] * e6p0;
adBcoef[10] = adBcoef[10]+ s3 * dWi[i] * dWi[j] * e12p0;
adBcoef[11] = adBcoef[11]+ s3 * dWi[i] * dWi[j] * e12p5;
adBcoef[12] = adBcoef[12] + s3 * dFi[i] * dFi[j] / e6p0;
adBcoef[13] = adBcoef[13] + s3 * e2p0;
adBcoef[14] = adBcoef[14] + s3 * e3p0;
adBcoef[15] = adBcoef[15] + s3 * dQi[i] * dQi[j] * e2p0;
adBcoef[16] = adBcoef[16] + s3 * e2p0;
adBcoef[17] = adBcoef[17] + s3 * e11p0;
}
}

for (i=0; i < 18; i++) adBcoef[i] *= adAn[i];

dKp3 = pow((k5p0 + k2p5 * k2p5), 0.6);
dU = pow((u5p0 + u2p5 * u2p5), 0.2);
dQp2 = q1p0 * q1p0;
}

void Detail::bvir(void)
{
double t0p5, t2p0, t3p0, t3p5, t4p5, t6p0, t11p0;
double t7p5, t9p5, t12p0, t12p5;
double t1p5, t4p0;
double Bx[18];
int i;

dB = ddBdT = dd2BdT2 = 0.0;

t0p5 = sqrt(dT);
t2p0 = dT * dT;
t3p0 = dT * t2p0;
t3p5 = t3p0 * t0p5;
t4p5 = dT * t3p5;
t6p0 = t3p0 * t3p0;
t11p0 = t4p5 * t4p5 * t2p0;
t7p5 = t6p0 * dT * t0p5;
t9p5 = t7p5 * t2p0;
t12p0 = t9p5 * t0p5 * t2p0;
t12p5 = t12p0 * t0p5;
t1p5 = dT * t0p5;
t4p0 = t2p0 * t2p0;

Bx[0] = adBcoef[0];
Bx[1] = adBcoef[1] / t0p5;
Bx[2] = adBcoef[2] / dT;
Bx[3] = adBcoef[3] / t3p5;
Bx[4] = adBcoef[4] * t0p5;
Bx[5] = adBcoef[5] / t4p5;
Bx[6] = adBcoef[6] / t0p5;
Bx[7] = adBcoef[7] / t7p5;
Bx[8] = adBcoef[8] / t9p5;
Bx[9] = adBcoef[9] / t6p0;
Bx[10] = adBcoef[10] / t12p0;
Bx[11] = adBcoef[11] / t12p5;
Bx[12] = adBcoef[12] * t6p0;
Bx[13] = adBcoef[13] / t2p0;
Bx[14] = adBcoef[14] / t3p0;
Bx[15] = adBcoef[15] / t2p0;
Bx[16] = adBcoef[16] / t2p0;
Bx[17] = adBcoef[17] / t11p0;

for (i= 0; i < 18; i++)
{
dB += Bx[i];
}

for (i= 0; i < 18; i++)
{
if (adUn[i]) Bx[i] *= adUn[i];
}

for (i= 0; i < 18; i++)
{
if (adUn[i])
ddBdT += Bx[i] / dT;
}

ddBdT = -ddBdT;

for (i= 0; i < 18; i++)
{
if (adUn[i] && adUn[i] != -1.0)
Bx[i] *= (adUn[i] + 1.0);
}

for (i= 0; i < 18; i++)
{
if (adUn[i] && adUn[i] != -1.0)
dd2BdT2 += Bx[i] / t2p0;
}
}

void Detail::temp(void)
{
double tr0p5, tr1p5, tr2p0, tr3p0, tr4p0, tr5p0, tr6p0;
double tr7p0, tr8p0, tr9p0, tr11p0, tr13p0, tr21p0;
double tr22p0, tr23p0, tr;

bvir();

tr = dT / (dU);

tr0p5 = sqrt(tr);
tr1p5 = tr * tr0p5;
tr2p0 = tr * tr;
tr3p0 = tr * tr2p0;
tr4p0 = tr * tr3p0;
tr5p0 = tr * tr4p0;
tr6p0 = tr * tr5p0;
tr7p0 = tr * tr6p0;
tr8p0 = tr * tr7p0;
tr9p0 = tr * tr8p0;
tr11p0 = tr6p0 * tr5p0;
tr13p0 = tr6p0 * tr7p0;
tr21p0 = tr9p0 * tr9p0 * tr3p0;
tr22p0 = tr * tr21p0;
tr23p0 = tr * tr22p0;

adFn[12] = adAn[12] * dF * tr6p0;
adFn[13] = adAn[13] / tr2p0;
adFn[14] = adAn[14] / tr3p0;
adFn[15] = adAn[15] * dQp2 / tr2p0;
adFn[16] = adAn[16] / tr2p0;
adFn[17] = adAn[17] / tr11p0;
adFn[18] = adAn[18] * tr0p5;
adFn[19] = adAn[19] / tr0p5;
adFn[20] = adAn[20];
adFn[21] = adAn[21] / tr4p0;
adFn[22] = adAn[22] / tr6p0;
adFn[23] = adAn[23] / tr21p0;
adFn[24] = adAn[24] * dW / tr23p0;
adFn[25] = adAn[25] * dQp2 / tr22p0;
adFn[26] = adAn[26] * dF * tr;
adFn[27] = adAn[27] * dQp2 * tr0p5;
adFn[28] = adAn[28] * dW / tr7p0;
adFn[29] = adAn[29] * dF * tr;
adFn[30] = adAn[30] / tr6p0;
adFn[31] = adAn[31] * dW / tr4p0;
adFn[32] = adAn[32] * dW / tr;
adFn[33] = adAn[33] * dW / tr9p0;
adFn[34] = adAn[34] * dF * tr13p0;
adFn[35] = adAn[35] / tr21p0;
adFn[36] = adAn[36] * dQp2 / tr8p0;
adFn[37] = adAn[37] * tr0p5;
adFn[38] = adAn[38];
adFn[39] = adAn[39] / tr2p0;
adFn[40] = adAn[40] / tr7p0;
adFn[41] = adAn[41] * dQp2 / tr9p0;
adFn[42] = adAn[42] / tr22p0;
adFn[43] = adAn[43] / tr23p0;
adFn[44] = adAn[44] / tr;
adFn[45] = adAn[45] / tr9p0;
adFn[46] = adAn[46] * dQp2 / tr3p0;
adFn[47] = adAn[47] / tr8p0;
adFn[48] = adAn[48] * dQp2 / tr23p0;
adFn[49] = adAn[49] / tr1p5;
adFn[50] = adAn[50] * dW / tr5p0;
adFn[51] = adAn[51] * dQp2 * tr0p5;
adFn[52] = adAn[52] / tr4p0;
adFn[53] = adAn[53] * dW / tr7p0;
adFn[54] = adAn[54] / tr3p0;
adFn[55] = adAn[55] * dW;
adFn[56] = adAn[56] / tr;
adFn[57] = adAn[57] * dQp2;
}

void Detail::ddetail(AGA10STRUCT *ptAGA10)
{
int imax, i;

double epsp, epsr, epsmin;
double x1, x2, x3, y1, y2, y3;
double delx, delprv, delmin, delbis, xnumer, xdenom, sgndel;
double y2my3, y3my1, y1my2, boundn;

imax = 150;
epsp = 1.e-6;
epsr = 1.e-6;
epsmin = 1.e-7;
dRho =0.0;

braket(ptAGA10);

if (ptAGA10->lStatus == MAX_NUM_OF_ITERATIONS_EXCEEDED ||
ptAGA10->lStatus == NEGATIVE_DENSITY_DERIVATIVE)
{
return;
}

x1 = dRhoL;
x2 = dRhoH;
y1 = dPRhoL - dP;
y2 = dPRhoH - dP;
delx = x1 - x2;
delprv = delx;

x3 = x1;
y3 = y1;

for (i=0; i < imax; i++)
{
if (y2 * y3 > 0.0)
{
x3 = x1;
y3 = y1;

delx = x1 - x2;
delprv = delx;
}

if (fabs(y3) < fabs(y2))
{
x1 = x2;
x2 = x3;
x3 = x1;
y1 = y2;
y2 = y3;
y3 = y1;
}

delmin = epsmin * fabs(x2);
delbis = 0.5 * (x3 - x2);

if (fabs(delprv) < delmin || fabs(y1) < fabs(y2))
{
delx = delbis;
delprv = delbis;
}
else
{
if (x3 != x1)
{
y2my3 = y2 - y3;
y3my1 = y3 - y1;
y1my2 = y1 - y2;

xdenom = -(y1my2) * (y2my3) * (y3my1);
xnumer = x1 * y2 * y3 * (y2my3)
+x2 * y3 * y1 * (y3my1)
+x3 * y1 * y2 * (y1my2) - x2 * xdenom;
}
else
{
xnumer = (x2-x1)*y2;
xdenom = y1-y2;
}

if (2.0 * fabs(xnumer) < fabs(delprv * xdenom))
{
delprv = delx;
delx = xnumer / xdenom;
}
else
{
delx = delbis;
delprv = delbis;
}
}

if ((fabs(y2) < epsp * dP) && (fabs(delx) < epsr * fabs(x2)))
{
dRho = x2 + delx;
return;
}

if (fabs(delx) < delmin)
{
sgndel = delbis / fabs(delbis);
delx = 1.0000009 * sgndel * delmin;
delprv = delx;
}

boundn = delx * (x2 + delx - x3);

if (boundn > 0.0)
{
delx = delbis;
delprv = delbis;
}

x1 = x2;
y1 = y2;
x2 = x2 + delx;

pdetail(x2);
y2 = dPCalc - dP;
}

ptAGA10->lStatus=MAX_NUM_OF_ITERATIONS_EXCEEDED;
dRho = x2;
}

void Detail::braket(AGA10STRUCT *ptAGA10)
{
int imax, it;

double del, rhomax, videal;
double rho1, rho2, p1, p2;

imax = 200;
rho1 = 0.0;
p1 = 0.0;
rhomax = 1.0 / dKp3;

if (dT > 1.2593 * dU) rhomax = 20.0 * rhomax;
videal = RGASKJ * dT / dP;

if (fabs(dB) < (0.167 * videal))
{
rho2 = 0.95 / (videal + dB);
}
else
{
rho2 = 1.15 / videal;
}

del = rho2 / 20.0;

for (it = 0; it < imax; it++)
{
if (rho2 > rhomax && ptAGA10->lStatus != MAX_DENSITY_IN_BRAKET_EXCEEDED)
{
ptAGA10->lStatus = MAX_DENSITY_IN_BRAKET_EXCEEDED;
del = 0.01 * (rhomax - rho1) + (dP / (RGASKJ * dT)) / 20.0;
rho2 = rho1 + del;
continue;
}

pdetail(rho2);
p2 = dPCalc;

if (p2 > dP)
{
dRhoL = rho1;
dPRhoL = p1;
dRhoH = rho2;
dPRhoH = p2;
ptAGA10->lStatus = NORMAL;
return;
}
else if (p2 > p1)
{
if (ptAGA10->lStatus == MAX_DENSITY_IN_BRAKET_EXCEEDED) del *= 2.0;
rho1 = rho2;
p1 = p2;
rho2 = rho1 + del;
continue;
}
else
{
ptAGA10->lStatus = NEGATIVE_DENSITY_DERIVATIVE;
dRho = rho1;
return;
}
}

ptAGA10->lStatus = MAX_NUM_OF_ITERATIONS_EXCEEDED;
dRho = rho2;
return;
}

void Detail::pdetail(double dD)
{
dPCalc = zdetail(dD) * dD * RGASKJ * dT;
}

double Detail::zdetail(double d)
{
double D1, D2, D3, D4, D5, D6, D7, D8, D9, exp1, exp2, exp3, exp4;

D1 = dKp3 * d;
D2 = D1 * D1;
D3 = D2 * D1;
D4 = D3 * D1;
D5 = D4 * D1;
D6 = D5 * D1;
D7 = D6 * D1;
D8 = D7 * D1;
D9 = D8 * D1;

exp1 = exp(-D1);
exp2 = exp(-D2);
exp3 = exp(-D3);
exp4 = exp(-D4);

dZ = 1.0 + dB * d
+adFn[12] * D1 * (exp3 - 1.0 - 3.0 * D3 * exp3)
+(adFn[13] + adFn[14] + adFn[15]) * D1 * (exp2 - 1.0 - 2.0 * D2 * exp2)
+(adFn[16] + adFn[17]) * D1 * (exp4 - 1.0 - 4.0 * D4 * exp4)
+(adFn[18] + adFn[19]) * D2 * 2.0
+(adFn[20] + adFn[21] + adFn[22]) * D2 * (2.0 - 2.0 * D2) * exp2
+(adFn[23] + adFn[24] + adFn[25]) * D2 * (2.0 - 4.0 * D4) * exp4
+adFn[26] * D2 * (2.0 - 4.0 * D4) * exp4
+adFn[27] * D3 * 3.0
+(adFn[28] + adFn[29]) * D3 * (3.0 - D1) * exp1
+(adFn[30] + adFn[31]) * D3 * (3.0 - 2.0 * D2) * exp2
+(adFn[32] + adFn[33]) * D3 * (3.0 - 3.0 * D3) * exp3
+(adFn[34] + adFn[35] + adFn[36]) * D3 * (3.0 - 4.0 * D4) * exp4
+(adFn[37] + adFn[38]) * D4 * 4.0
+(adFn[39] + adFn[40] + adFn[41]) * D4 * (4.0 - 2.0 * D2) * exp2
+(adFn[42] + adFn[43]) * D4 * (4.0 - 4.0 * D4) * exp4
+adFn[44] * D5 * 5.0
+(adFn[45] + adFn[46]) * D5 * (5.0 - 2.0 * D2) * exp2
+(adFn[47] + adFn[48]) * D5 * (5.0 - 4.0 * D4) * exp4
+adFn[49] * D6 * 6.0
+adFn[50] * D6 * (6.0 - 2.0 * D2) * exp2
+adFn[51] * D7 * 7.0
+adFn[52] * D7 * (7.0 - 2.0 * D2) * exp2
+adFn[53] * D8 * (8.0 - D1) * exp1
+(adFn[54] + adFn[55]) * D8 * (8.0 - 2.0 * D2) * exp2
+(adFn[56] + adFn[57]) * D9 * (9.0 - 2.0 * D2) * exp2;

return dZ;
}

double Detail::dZdT(double d)
{
double tmp;
int i;

double D1, D2, D3, D4, D5, D6, D7, D8, D9, exp1, exp2, exp3, exp4;

D1 = dKp3 * d;
D2 = D1 * D1;
D3 = D2 * D1;
D4 = D3 * D1;
D5 = D4 * D1;
D6 = D5 * D1;
D7 = D6 * D1;
D8 = D7 * D1;
D9 = D8 * D1;

exp1 = exp(-D1);
exp2 = exp(-D2);
exp3 = exp(-D3);
exp4 = exp(-D4);

for (i=12; i < 58; i++)
{
if (adUn[i] && adFn[i])
{
fx[i] = (adFn[i] * adUn[i] * D1) / dT;
}
else
{
fx[i] = 0.0;
}
}

ddZdT = d * ddBdT;

if (dF) ddZdT += fx[12] - (fx[12] * (1.0 - 3.0 * D3) * exp3);

tmp = (1.0 - 2.0 * D2) * exp2;
ddZdT += (fx[13] - (fx[13] * tmp));
ddZdT += fx[14] - (fx[14] * tmp);
ddZdT += fx[15] - (fx[15] * tmp);

tmp = (1.0 - 4.0 * D4) * exp4;
ddZdT += fx[16] - (fx[16] * tmp);
ddZdT += fx[17] - (fx[17] * tmp);

ddZdT = ddZdT - (fx[18] + fx[19]) * D1 * 2.0
-(fx[21] + fx[22]) * D1 * (2.0 - 2.0 * D2) * exp2
-(fx[23] + fx[24] + fx[25]) * D1 * (2.0 - 4.0 * D4) * exp4
-fx[26] * D1 * (2.0 - 4.0 * D4) * exp4
-fx[27] * D2 * 3.0
-(fx[28] + fx[29]) * D2 * (3.0 - D1) * exp1
-(fx[30] + fx[31]) * D2 * (3.0 - 2.0 * D2) * exp2
-(fx[32] + fx[33]) * D2 * (3.0 - 3.0 * D3) * exp3
-(fx[34] + fx[35] + fx[36]) * D2 * (3.0 - 4.0 * D4) * exp4
-fx[37] * D3 * 4.0
-(fx[39] + fx[40] + fx[41]) * D3 * (4.0 - 2.0 * D2) * exp2
-(fx[42] + fx[43]) * D3 * (4.0 - 4.0 * D4) * exp4
-fx[44] * D4 * 5.0
-(fx[45] + fx[46]) * D4 * (5.0 - 2.0 * D2) * exp2
-(fx[47] + fx[48]) * D4 * (5.0 - 4.0 * D4) * exp4
-fx[49] * D5 * 6.0
-fx[50] * D5 * (6.0 - 2.0 * D2) * exp2
-fx[51] * D6 * 7.0
-fx[52] * D6 * (7.0 - 2.0 * D2) * exp2
-fx[53] * D7 * (8.0 - D1) * exp1
-fx[54] * D7 * (8.0 - 2.0 * D2) * exp2
-fx[56] * D8 * (9.0 - 2.0 * D2) * exp2;

return ddZdT;
}

double Detail::d2ZdT2(double d)
{
double tmp;
int i;

double D1, D2, D3, D4, D5, D6, D7, D8, D9, exp1, exp2, exp3, exp4;

D1 = dKp3 * d;
D2 = D1 * D1;
D3 = D2 * D1;
D4 = D3 * D1;
D5 = D4 * D1;
D6 = D5 * D1;
D7 = D6 * D1;
D8 = D7 * D1;
D9 = D8 * D1;

exp1 = exp(-D1);
exp2 = exp(-D2);
exp3 = exp(-D3);
exp4 = exp(-D4);

for (i=12; i < 58; i++)
{
if (adUn[i] && adFn[i])
{
fx[i] = (adFn[i] * D1 * adUn[i] * (adUn[i] + 1.0)) / (dT * dT);
}
else
{
fx[i] = 0.0;
}
}

dd2ZdT2 = d * dd2BdT2;

if (dF) dd2ZdT2 += fx[12] - (fx[12] * (1.0 - 3.0 * D3) * exp3);

tmp = (1.0 - 2.0 * D2) * exp2;
dd2ZdT2 += -fx[13] + (fx[13] * tmp);
dd2ZdT2 += -fx[14] + (fx[14] * tmp);
dd2ZdT2 += -fx[15] + (fx[15] * tmp);

tmp = (1.0 - 4.0 * D4) * exp4;
dd2ZdT2 += -fx[16] + (fx[16] * tmp);
dd2ZdT2 += -fx[17] + (fx[17] * tmp);

dd2ZdT2 = dd2ZdT2 + (fx[18] + fx[19]) * D1 * 2.0
+(fx[21] + fx[22]) * D1 * (2.0 - 2.0 * D2) * exp2
+(fx[23] + fx[24] + fx[25]) * D1 * (2.0 - 4.0 * D4) * exp4
+fx[26] * D1 * (2.0 - 4.0 * D4) * exp4
+fx[27] * D2 * 3.0
+(fx[28] + fx[29]) * D2 * (3.0 - D1) * exp1
+(fx[30] + fx[31]) * D2 * (3.0 - 2.0 * D2) * exp2
+(fx[32] + fx[33]) * D2 * (3.0 - 3.0 * D3) * exp3
+(fx[34] + fx[35] + fx[36]) * D2 * (3.0 - 4.0 * D4) * exp4
+fx[37] * D3 * 4.0
+(fx[39] + fx[40] + fx[41]) * D3 * (4.0 - 2.0 * D2) * exp2
+(fx[42] + fx[43]) * D3 * (4.0 - 4.0 * D4) * exp4
+fx[44] * D4 * 5.0
+(fx[45] + fx[46]) * D4 * (5.0 - 2.0 * D2) * exp2
+(fx[47] + fx[48]) * D4 * (5.0 - 4.0 * D4) * exp4
+fx[49] * D5 * 6.0
+fx[50] * D5 * (6.0 - 2.0 * D2) * exp2
+fx[51] * D6 * 7.0
+fx[52] * D6 * (7.0 - 2.0 * D2) * exp2
+fx[53] * D7 * (8.0 - D1) * exp1
+fx[54] * D7 * (8.0 - 2.0 * D2) * exp2
+fx[56] * D8 * (9.0 - 2.0 * D2) * exp2;

return dd2ZdT2;
}

double Detail::dZdD(double d)
{
double temp, temp1, temp2, temp3;
int i;

double D1, D2, D3, D4, D5, D6, D7, D8, D9, exp1, exp2, exp3, exp4;

D1 = dKp3 * d;
D2 = D1 * D1;
D3 = D2 * D1;
D4 = D3 * D1;
D5 = D4 * D1;
D6 = D5 * D1;
D7 = D6 * D1;
D8 = D7 * D1;
D9 = D8 * D1;

exp1 = exp(-D1);
exp2 = exp(-D2);
exp3 = exp(-D3);
exp4 = exp(-D4);

for (i=12; i < 58; i++)
{
fx[i] = adFn[i];
}

ddZdD = dB / dKp3;

if (dF)
{
temp1 = -9.0 * D3 * exp3;
temp2 = (1.0 - 3.0 * D3) * exp3;
temp3 = -temp2 * 3.0 * D6;
temp = temp1 + temp2 + temp3;
ddZdD += -fx[12] + fx[12] * temp;
}

temp1 = -4.0 * D2 * exp2;
temp2 = (1.0 - 2.0 * D2) * exp2;
temp3 = -temp2 * 2.0 * D2;
temp = temp1 + temp2 + temp3;
ddZdD += -fx[13] + fx[13] * temp;
ddZdD += -fx[14] + fx[14] * temp;
ddZdD += -fx[15] + fx[15] * temp;

temp1 = -16.0 * D4 * exp4;
temp2 = (1.0 - 4.0 * D4) * exp4;
temp3 = -temp2 * 4.0 * D4;
temp = temp1 + temp2 + temp3;
ddZdD += -fx[16] + fx[16] * temp;
ddZdD += -fx[17] + fx[17] * temp;

temp = 4.0 * D1;
ddZdD += fx[18] * temp;
ddZdD += fx[19] * temp;

temp1 = -4.0 * D3 * exp2;
temp2 = (2.0 - 2.0 * D2) * 2.0 * D1 * exp2;
temp3 = -temp2 * D2;
temp = temp1 + temp2 + temp3;
ddZdD += fx[20] * temp;
ddZdD += fx[21] * temp;
ddZdD += fx[22] * temp;

temp1 = -16.0 * D5 * exp4;
temp2 = (2.0 - 4.0 * D4) * 2.0 * D1 * exp4;
temp3 = -temp2 * 2.0 * D4;
temp = temp1 + temp2 + temp3;
ddZdD += fx[23] * temp;
ddZdD += fx[24] * temp;
ddZdD += fx[25] * temp;
ddZdD += fx[26] * temp;

temp = 9.0 * D2;
ddZdD += fx[27] * temp;

temp = -D3 * exp1 + (3.0 - D1) * 3.0 * D2 * exp1;
temp -= (3.0 - D1) * D3 * exp1;
ddZdD += fx[28] * temp;
ddZdD += fx[29] * temp;

temp1 = -4.0 * D4 * exp2;
temp2 = (3.0 - 2.0 * D2) * 3.0 * D2 * exp2;
temp3 = -(3.0 - 2.0 * D2) * 2.0 * D4 * exp2;
temp = temp1 + temp2 + temp3;
ddZdD += fx[30] * temp;
ddZdD += fx[31] * temp;

temp1 = -9.0 * D5 * exp3;
temp2 = (3.0 - 3.0 * D3) * 3.0 * D2 * exp3;
temp3 = -(3.0 - 3.0 * D3) * 3.0 * D5 * exp3;
temp = temp1 + temp2 + temp3;
ddZdD += fx[32] * temp;
ddZdD += fx[33] * temp;

temp1 = -16.0 * D6 * exp4;
temp2 = (3.0 - 4.0 * D4) * 3.0 * D2 * exp4;
temp3 = -(3.0 - 4.0 * D4) * D6 * 4.0 * exp4;
temp = temp1 + temp2 + temp3;
ddZdD += fx[34] * temp;
ddZdD += fx[35] * temp;
ddZdD += fx[36] * temp;

temp = 16.0 * D3;
ddZdD += fx[37] * temp;
ddZdD += fx[38] * temp;

temp1 = -4.0 * D5 * exp2;
temp2 = (4.0 - 2.0 * D2) * 4.0 * D3 * exp2;
temp3 = -(4.0 - 2.0 * D2) * 2.0 * D5 * exp2;
temp = temp1 + temp2 + temp3;
ddZdD += fx[39] * temp;
ddZdD += fx[40] * temp;
ddZdD += fx[41] * temp;

temp = -16.0 * D7 * exp4 + (4.0 - 4.0 * D4) * 4.0 * D3 * exp4;
temp -= (4.0 - 4.0 * D4) * D7 * 4.0 * exp4;
ddZdD += fx[42] * temp;
ddZdD += fx[43] * temp;

temp = 25.0 * D4;
ddZdD += fx[44] * temp;

temp = -4.0 * D6 * exp2 + (5.0 - 2.0 * D2) * 5.0 * D4 * exp2;
temp -= (5.0 - 2.0 * D2) * D6 * 2.0 * exp2;
ddZdD += fx[45] * temp;
ddZdD += fx[46] * temp;

temp = -16.0 * D8 * exp4 + (5.0 - 4.0 * D4) * 5.0 * D4 * exp4;
temp -= (5.0 - 4.0 * D4) * D8 * 4.0 * exp4;
ddZdD += fx[47] * temp;
ddZdD += fx[48] * temp;

temp = 36.0 * D5;
ddZdD += fx[49] * temp;

temp = -4.0 * D7 * exp2 + (6.0 - 2.0 * D2) * 6.0 * D5 * exp2;
temp -= (6.0 - 2.0 * D2) * D7 * 2.0 * exp2;
ddZdD += fx[50] * temp;

temp = 49.0 * D6;
ddZdD += fx[51] * temp;

temp = -4.0 * D8 * exp2 + (7.0 - 2.0 * D2) * 7.0 * D6 * exp2;
temp -= (7.0 - 2.0 * D2) * D8 * 2.0 * exp2;
ddZdD += fx[52] * temp;

temp = -1.0 * D8 * exp1 + (8.0 - D1) * 8.0 * D7 * exp1;
temp -= (8.0 - D1) * D8 * exp1;
ddZdD += fx[53] * temp;

temp = -4.0 * D1 * D8 * exp2 + (8.0 - 2.0 * D2) * 8.0 * D7 * exp2;
temp -= (8.0 - 2.0 * D2) * D8 * 2.0 * D1 * exp2;
ddZdD += fx[54] * temp;
ddZdD += fx[55] * temp;

temp = -4.0 * D2 * D8 * exp2 + (9.0 - 2.0 * D2) * 9.0 * D8 * exp2;
temp -= (9.0 - 2.0 * D2) * D2 * D8 * 2.0 * exp2;
ddZdD += fx[56] * temp;
ddZdD += fx[57] * temp;

ddZdD *= dKp3;

return ddZdD;
}

void Detail::relativedensity(AGA10STRUCT *ptAGA10)
{
double dBX, dZa;

const double dMWair = 28.96256;

dBX = -0.12527 + 5.91e-4 * ptAGA10->dTb - 6.62e-7 * ptAGA10->dTb * ptAGA10->dTb;

dZa = 1.0 + (dBX * dP) / (RGASKJ * ptAGA10->dTb);

ptAGA10->dRD_Ideal = ptAGA10->dMrx / dMWair;
ptAGA10->dRD_Real = ptAGA10->dRD_Ideal * (dZa / ptAGA10->dZb);
}