public TransCon(TransCon con)
{
Clear();
foreach (float x in con)
{
Add(x);
}
inParams = con.inParams;
}
private float calcHeightWidth(TransCon compconu, TransCon compconl, int offsetu, int offsetl, bool inverseu, bool inversel, float nsteps, float peakpos, float peakheight)
{
// outComp width : determine at set height
float width;
float wheight = 0.6065f * peakheight;
float pos1 = peakpos;
float pos2 = peakpos;
float cu, cl;
float con;
float lastcon = 0;
for (int i = (int)peakpos; i > 0; i--)
{
cu = compconu.getNormCon(i, offsetu, inverseu);
cl = compconl.getNormCon(i, offsetl, inversel);
con = cu + cl;
if (con < wheight && i != peakpos)
{
// interpolate
pos1 = Util.calcCorX(i + 1, i, lastcon, con, wheight);
break;
}
lastcon = con;
}
for (int i = (int)peakpos; i < nsteps; i++)
{
cu = compconu.getNormCon(i, offsetu, inverseu);
cl = compconl.getNormCon(i, offsetl, inversel);
con = cu + cl;
if (con < wheight && i != peakpos)
{
// interpolate
pos2 = Util.calcCorX(i - 1, i, lastcon, con, wheight);
break;
}
lastcon = con;
}
width = 2 * Math.Abs(pos2 - pos1);
return(width);
}
private void transfer()
{
TransCon newcompconu;
TransCon newcompconl;
TransCon compconu;
TransCon compconl;
Comp comp;
float cu, cl, cu0, cl0;
float k;
float dc, dcu, dcl;
float tmu = inParams.Tmu * 60; // assume [min] => [s]
float tml = inParams.Tml * 60; // assume [min] => [s]
float tmnorm = inParams.Tmnorm * 60; // assume [min] => [s]
float tm;
bool inverseu, inversel;
int offsetu, offsetl;
int nsteps;
int i, i0, j;
float ka = inParams.ka;
bool intPhaseSwitch = false;
int deadvolstartsteps = (int)Math.Round(inParams.getVdeadStart());
int deadvolendsteps = (int)Math.Round(inParams.getVdeadEnd());
int deadvolinsertstartsteps = (int)Math.Round(inParams.getVdeadInjectStart());
int deadvolinsertendsteps = (int)Math.Round(inParams.getVdeadInjectEnd());
if (inParams.runMode == RunModeType.CoCurrent)
{
inverseu = false;
inversel = false;
offsetu = 0;
offsetl = 0;
}
else
{
inverseu = false;
inversel = true;
offsetu = 0;
offsetl = inParams.column2;
}
for (int compi = 0; compi < inParams.comps.Count; compi++)
{
compconu = conu[compi];
compconl = conl[compi];
comp = inParams.comps[compi];
if (fullmasstransfer)
{
nsteps = compconu.Count + compconl.Count - inParams.column2;
if (inParams.runMode != RunModeType.CoCurrent)
{
offsetu = compconl.Count - inParams.column2;
offsetl = compconl.Count;
}
}
else
{
nsteps = inParams.column2;
}
// buffer for modified values
newcompconu = new TransCon(compconu);
newcompconl = new TransCon(compconl);
k = comp.k;
// phase movement (on buffered values)
// mobile upper phase movement
if (curPhase == PhaseType.Upper || curPhase == PhaseType.Both)
{
for (i = nsteps - 1; i >= 0; i--)
{
if (inParams.runMode == RunModeType.CoCurrent && i > inParams.column2)
{
tm = tmnorm;
}
else
{
tm = tmu;
}
cu = compconu.getNorm(i, offsetu, inverseu);
cu0 = compconu.getNorm(i - 1, offsetu, inverseu);
dcu = -tmnorm / tm * (cu - cu0) / dx;
if (dcu != 0)
{
cu = newcompconu.getNorm(i, offsetu, inverseu);
newcompconu.setNorm(i, offsetu, inverseu, cu + dcu * dt);
}
}
}
// mobile lower phase movement
if (curPhase == PhaseType.Lower || curPhase == PhaseType.Both)
{
for (j = 0; j < nsteps; j++)
{
if (inParams.runMode == RunModeType.CoCurrent)
{
i = nsteps - 1 - j;
// normal order: current OutCell - previous OutCell
i0 = i - 1;
}
else
{
i = j;
// inverse order: current OutCell - next OutCell
i0 = i + 1;
}
if (inParams.runMode == RunModeType.CoCurrent && i > inParams.column2)
{
tm = tmnorm;
}
else
{
tm = tml;
}
cl = compconl.getNorm(i, offsetl, inversel);
cl0 = compconl.getNorm(i0, offsetl, inversel);
dcl = -tmnorm / tm * (cl - cl0) / dx;
if (dcl != 0)
{
cl = newcompconl.getNorm(i, offsetl, inversel);
newcompconl.setNorm(i, offsetl, inversel, cl + dcl * dt);
}
}
}
// copy back buffer: overwrite original values
conu[compi] = newcompconu;
conl[compi] = newcompconl;
compconu = conu[compi];
compconl = conl[compi];
// do transfer between phases, over moved phases (on original values)
// transfer between phases
if (inParams.runMode != RunModeType.CoCurrent)
{
offsetu = 0;
offsetl = inParams.column2;
}
for (i = 0; i < inParams.column2; i++)
{
// don't redistribute in dead volumes
if (i >= deadvolstartsteps && i < deadvolendsteps && (i < deadvolinsertstartsteps || i >= deadvolinsertendsteps))
{
// active cells
cu = compconu.getNorm(i, offsetu, inverseu);
cl = compconl.getNorm(i, offsetl, inversel);
dc = Equations.calcDc(inParams.kDefinition, cu, cl, k);
dcu = tmnorm * ka / inParams.uf * dc;
dcl = -tmnorm * ka / inParams.lf * dc;
if (dcu != 0)
{
compconu.setNorm(i, offsetu, inverseu, cu + dcu * dt);
}
if (dcl != 0)
{
compconl.setNorm(i, offsetl, inversel, cl + dcl * dt);
}
}
}
}
if (curPhase == PhaseType.Upper || curPhase == PhaseType.Both || (inParams.runMode == RunModeType.Intermittent && inParams.viewUnits == QuantityType.Time))
{
if (inParams.runMode == RunModeType.CoCurrent)
{
tm = tmnorm;
}
else
{
tm = tmu;
}
fdtxu += dtx * tmnorm / tm;
while (fdtxu > 1)
{
for (int compi = 0; compi < inParams.comps.Count; compi++)
{
compconu = conu[compi];
if (curPhase == PhaseType.Upper || curPhase == PhaseType.Both)
{
if (fullmasstransfer)
{
compconu.Add(0);
}
else
{
compconu.insertAfterCol(compconu.getLastCol());
}
}
else
{
compconu.insertAfterCol(0);
}
}
fdtxu -= 1;
}
}
if (curPhase == PhaseType.Lower || curPhase == PhaseType.Both || (inParams.runMode == RunModeType.Intermittent && inParams.viewUnits == QuantityType.Time))
{
if (inParams.runMode == RunModeType.CoCurrent)
{
tm = tmnorm;
}
else
{
tm = tml;
}
fdtxl += dtx * tmnorm / tm;
while (fdtxl > 1)
{
for (int compi = 0; compi < inParams.comps.Count; compi++)
{
compconl = conl[compi];
if (curPhase == PhaseType.Lower || curPhase == PhaseType.Both)
{
if (fullmasstransfer)
{
compconl.Add(0);
}
else
{
compconl.insertAfterCol(compconl.getLastCol());
}
}
else
{
compconl.insertAfterCol(0);
}
}
fdtxl -= 1;
}
}
if (inParams.runMode == RunModeType.Intermittent)
{
if (inParams.intMode != IntModeType.Component)
{
if (curPhase == PhaseType.Upper)
{
intamountu -= dtreal;
if (intamountu <= 0)
{
intPhaseSwitch = true;
}
}
if (curPhase == PhaseType.Lower)
{
intamountl -= dtreal;
if (intamountl <= 0)
{
intPhaseSwitch = true;
}
}
}
if (intPhaseSwitch && intit / 2 < inParams.intMaxIt)
{
if (curPhase == PhaseType.Upper)
{
curPhase = PhaseType.Lower;
}
else
{
curPhase = PhaseType.Upper;
}
intit++;
newIntAmount();
}
}
runcols += (1.0f / timesteps);
}
private float calcSlopeWidth(TransCon compconu, TransCon compconl, int offsetu, int offsetl, bool inverseu, bool inversel, float nsteps, float peakpos)
{
// outComp width : look for slopes closest to max outComp value
float width;
float pos1 = peakpos;
float pos2 = peakpos;
float maxpos = peakpos;
float maxpos0 = peakpos;
float maxcon = 0;
float maxcon0 = 0;
float cu, cl;
float con;
float con0 = 0;
float dcon, maxdcon;
maxdcon = 0;
for (int i = (int)peakpos; i > 0; i--)
{
cu = compconu.getNormCon(i, offsetu, inverseu);
cl = compconl.getNormCon(i, offsetl, inversel);
con = cu + cl;
if (i != peakpos)
{
dcon = con0 - con;
if (dcon > maxdcon)
{
maxdcon = dcon;
maxcon = con;
maxcon0 = con0;
maxpos = i;
maxpos0 = i + 1;
}
}
con0 = con;
}
// extrapolate slope (y = 0)
pos1 = Util.calcCorX(maxpos0, maxpos, maxcon0, maxcon, 0);
maxdcon = 0;
for (int i = (int)peakpos; i < nsteps; i++)
{
cu = compconu.getNormCon(i, offsetu, inverseu);
cl = compconl.getNormCon(i, offsetl, inversel);
con = cu + cl;
if (i != peakpos)
{
dcon = con0 - con;
if (dcon > maxdcon)
{
maxdcon = dcon;
maxcon = con;
maxcon0 = con0;
maxpos = i;
maxpos0 = i - 1;
}
}
con0 = con;
}
// extrapolate slope (y = 0)
pos2 = Util.calcCorX(maxpos0, maxpos, maxcon0, maxcon, 0);
width = Math.Abs(pos2 - pos1);
return(width);
}
