public override void writeData(string fileName, ViewParams viewParams, int timei)
{
if (model != null)
{
model.writeData(fileName, viewParams, timei);
}
}
public void updateTimeVisOut(ViewParams viewParams)
{
int ntime = outParams.timeOutSet.Count;
outParams.timeVisOutSet = new List <VisOutSet>(ntime);
for (int timei = 0; timei < ntime; timei++)
{
outParams.timeVisOutSet.Add(updateVisOutVar(outParams.timeOutSet[timei], viewParams));
}
}
public void updateTimeOut(ViewParams viewParams)
{
stats.start();
storeTimeOut(viewParams);
stats.storeOutTime();
stats.start();
updateTimeVisOut(viewParams);
stats.storeVisoutTime();
}
public void updateMenus(ViewParams viewParams)
{
bool enabled = (viewParams.viewType == ViewType.Out || viewParams.viewType == ViewType.Time);
if (viewParams.altMode)
{
mainWindow.exportImagesMenuItem.Visibility = Visibility.Visible;
}
else
{
mainWindow.exportImagesMenuItem.Visibility = Visibility.Collapsed;
}
mainWindow.exportDataMenuItem.IsEnabled = enabled;
mainWindow.exportImageMenuItem.IsEnabled = enabled;
mainWindow.exportImagesMenuItem.IsEnabled = (viewParams.viewType == ViewType.Time);
mainWindow.reportMenuItem.IsEnabled = enabled;
mainWindow.printPreviewMenuItem.IsEnabled = enabled;
mainWindow.printMenuItem.IsEnabled = enabled;
//mainWindow.viewMenuItem.IsEnabled = enabled;
mainWindow.phaseMenuItem.IsEnabled = enabled;
mainWindow.peakMenuItem.IsEnabled = enabled;
mainWindow.xScaleMenuItem.IsEnabled = enabled;
mainWindow.yScaleMenuItem.IsEnabled = enabled;
mainWindow.phaseUpperLowerTimeMenuItem.IsChecked = (viewParams.phaseDisplay == PhaseDisplayType.UpperLowerTime);
mainWindow.phaseUpperLowerMenuItem.IsChecked = (viewParams.phaseDisplay == PhaseDisplayType.UpperLower);
mainWindow.phaseAllMenuItem.IsChecked = (viewParams.phaseDisplay == PhaseDisplayType.All);
mainWindow.phaseUpperMenuItem.IsChecked = (viewParams.phaseDisplay == PhaseDisplayType.Upper);
mainWindow.phaseLowerMenuItem.IsChecked = (viewParams.phaseDisplay == PhaseDisplayType.Lower);
mainWindow.peaksMenuItem.IsChecked = (viewParams.peaksDisplay == PeaksDisplayType.Peaks);
mainWindow.peaksSumMenuItem.IsChecked = (viewParams.peaksDisplay == PeaksDisplayType.PeaksSum);
mainWindow.sumMenuItem.IsChecked = (viewParams.peaksDisplay == PeaksDisplayType.Sum);
mainWindow.intTotalsMenuItem.IsChecked = (viewParams.peaksDisplay == PeaksDisplayType.IntTotals);
mainWindow.probUnitsMenuItem.IsChecked = viewParams.showProbUnits;
mainWindow.xScaleStepsMenuItem.IsChecked = (viewParams.viewUnits == QuantityType.Steps);
mainWindow.xScaleVolumeMenuItem.IsChecked = (viewParams.viewUnits == QuantityType.Volume);
mainWindow.xScaleTimeMenuItem.IsChecked = (viewParams.viewUnits == QuantityType.Time);
mainWindow.xScaleNormalisedMenuItem.IsChecked = (viewParams.viewUnits == QuantityType.Column);
mainWindow.xScaleResMenuItem.IsChecked = (viewParams.viewUnits == QuantityType.ReS);
mainWindow.syncScalesMenuItem.IsChecked = viewParams.syncScales;
mainWindow.yScaleAutomaticMenuItem.IsChecked = (viewParams.yScale == YScaleType.Automatic);
mainWindow.yScaleNormalisedMenuItem.IsChecked = (viewParams.yScale == YScaleType.Normalised);
mainWindow.yScaleAbsoluteMenuItem.IsChecked = (viewParams.yScale == YScaleType.Absolute);
mainWindow.yScaleLogarithmicMenuItem.IsChecked = (viewParams.yScale == YScaleType.Logarithmic);
mainWindow.exponentsMenuItem.IsChecked = (viewParams.exponentType == ExponentType.Exponents);
mainWindow.prefixesMenuItem.IsChecked = (viewParams.exponentType == ExponentType.Prefixes);
}
public override void updatePreview(InParamsExt inParams, ViewParams viewParams, OptionParams optionParams)
{
if (preview == null)
{
preview = new PreviewModel(this, inParams, optionParams);
}
preview.update(inParams, null);
preview.updateOut(viewParams);
preview.stats.start();
updatePreviewObservers();
preview.stats.storeDrawviewTime();
}
public void writeData(string filename, ViewParams viewParams, int time)
{
if (viewParams.viewType == ViewType.Out)
{
writeOut(filename, viewParams, outParams.outSet.unitsOutCells);
//writeOutRaw(filename,viewparams,inparams,outParams.outSet.rawOutCells);
}
else if (viewParams.viewType == ViewType.Time)
{
writeOut(filename, viewParams, outParams.timeOutSet[time].unitsOutCells);
}
}
public override void storeTimeOut(ViewParams viewParams)
{
int ntime;
model.updateProgress(0);
ntime = timeConu.Count;
outParams.timeOutSet = new List <OutSet>(ntime);
for (int timei = 0; timei < ntime; timei++)
{
outParams.timeOutSet.Add(storeOutVar(timeConu[timei], timeConl[timei], viewParams, true, timeTime[timei]));
model.updateProgress((float)timei / ntime);
}
model.clearProgress();
}
public ProView(ProControllerInterface controller,
ControlParams controlParams,
OptionParams optionParams,
ViewParams viewParams,
ProModelInterface model)
{
this.controller = controller;
this.controlParams = controlParams;
this.optionParams = optionParams;
this.viewParams = viewParams;
this.model = model;
model.registerPreviewObserver(this);
model.registerModelObserver(this);
}
public abstract void storeTimeOut(ViewParams viewParams);
public override void updateModel(InParamsExt inParams, ViewParams viewParams, OptionParams optionParams, ViewType viewType, bool updateModelReq, bool updateOutReq)
{
modelThread = new Thread(new ParameterizedThreadStart(updateModelThreadFunction));
modelThread.Start(new ModelRunParams(inParams, viewParams, optionParams, viewType, updateModelReq, updateOutReq));
}
public abstract void updateModel(InParamsExt inParams, ViewParams viewParams, OptionParams optionParams, ViewType viewType, bool updateModelReq, bool updateOutReq);
public OutSet storeOutVar(ViewParams viewParams)
{
// use predictive equations
OutSet outSet = new OutSet(inParams);
OutCell[][] outCells;
Axes axes;
Comp comp;
OutComp outComp;
OutComp outCompt = null;
float pos, pos0, post;
float totposu, totposl;
float timepos;
float maxtime0;
float eepos = 0;
float intAmount = 0;
float sigma, sigma0;
float timesigma = 0;
float con, maxcon;
float amp0;
float div0;
float maxposu = 0;
float maxposl = 0;
float mindrawpos = 0;
float maxdrawpos = 0;
float range;
float stepsize;
int ncomps = inParams.comps.Count;
int nsize = 1000;
float k;
PhaseType phase = new PhaseType();
KdefType kdef = inParams.kDefinition;
RunModeType runMode = inParams.runMode;
QuantityType natUnits = inParams.natUnits;
float injectPos = 0;
float lf = inParams.lf;
float uf = inParams.uf;
float px = inParams.px;
float fu = 0;
float fl = 0;
float fnormu = 0;
float fnorml = 0;
float vc = 0;
float mixspeed = 0;
float efficiency = 0;
bool allincol = true;
bool timeMode = (inParams.viewUnits == QuantityType.Time);
bool eeMode = (inParams.eeMode != EEModeType.None);
bool intMode = (inParams.runMode == RunModeType.Intermittent);
bool intCompMode = (inParams.intMode == IntModeType.Component);
int intit;
bool eluted;
float elutable;
eeDone = false;
if (inParams.model == ModelType.CCD)
{
// [steps]
vc = inParams.column;
injectPos = inParams.getInjectPosNorm();
if (runMode == RunModeType.CoCurrent)
{
injectPos = (inParams.column - 1) - injectPos;
}
fnormu = inParams.fnormu;
fnorml = inParams.fnorml;
// always use normalised flows
fu = fnormu;
fl = fnorml;
mixspeed = 1;
efficiency = Equations.calcEff1(inParams.efficiency);
}
else if (inParams.model == ModelType.Probabilistic)
{
// [volume]
vc = inParams.vc;
injectPos = inParams.getInjectPosNorm();
fu = inParams.fu;
fl = inParams.fl;
// normalise flow
fnormu = inParams.fnormu;
fnorml = inParams.fnorml;
if (fnorml > fnormu)
{
fnormu /= fnorml;
fnorml = 1;
}
else
{
fnorml /= fnormu;
fnormu = 1;
}
mixspeed = inParams.mixSpeed;
efficiency = Equations.calcEff1(inParams.efficiency);
}
else if (inParams.model == ModelType.Transport)
{
// [time]
natUnits = QuantityType.Time;
vc = inParams.vc;
injectPos = inParams.getInjectPosNorm();
fu = inParams.fu;
fl = inParams.fl;
// normalise flow
fnormu = fu / uf;
fnorml = fl / lf;
if (fnorml > fnormu)
{
fnormu /= fnorml;
fnorml = 1;
}
else
{
fnorml /= fnormu;
fnormu = 1;
}
mixspeed = 1;
efficiency = (float)Math.Sqrt(inParams.ka * 10); // **** make correct for f? dx? dt?
}
if (runMode != RunModeType.CoCurrent)
{
fl = -fl;
fnorml = -fnorml;
}
// Set maxpos
for (int compi = 0; compi < ncomps; compi++)
{
comp = inParams.comps[compi];
outComp = outSet.comps[compi];
elutable = Equations.calcElutable(kdef, fu, fl, outComp.k);
outComp.willElute = (elutable > 0.01);
if (outComp.willElute)
{
outCompt = calcNewPos(comp, fu, fl, vc, injectPos, natUnits); // outcomp is reassigned
outComp = outSet.comps[compi]; // overwrite comp
outComp.willElute = true; // restore willElute
if (comp.elute)
{
if (outCompt.retention < 0)
{
phase = PhaseType.Lower;
if (Math.Abs(outCompt.retention) > maxposl)
{
maxposl = Math.Abs(outCompt.retention);
}
}
else
{
phase = PhaseType.Upper;
if (Math.Abs(outCompt.retention) > maxposu)
{
maxposu = Math.Abs(outCompt.retention);
}
}
sigma = Equations.calcSigma(kdef, fnormu, fnorml, comp.k * px, outCompt.retentionTime, mixspeed, efficiency);
if (runMode == RunModeType.DualMode && inParams.model != ModelType.Transport)
{
sigma *= 2;
}
sigma = inParams.convertUnit(sigma, QuantityType.Time, natUnits, phase);
}
}
else
{
if (intMode && inParams.intFinalElute)
{
outComp.willElute = true;
}
}
}
if (intMode && !intCompMode)
{
intamountu = inParams.convertUnit(inParams.intUpSwitch, (QuantityType)inParams.intMode, natUnits, PhaseType.Upper);
intamountl = inParams.convertUnit(inParams.intLpSwitch, (QuantityType)inParams.intMode, natUnits, PhaseType.Lower);
if (inParams.model == ModelType.CCD)
{
intamountut = intamountu;
}
else
{
intamountut = inParams.convertUnit(inParams.intUpSwitch, (QuantityType)inParams.intMode, QuantityType.Time, PhaseType.Upper);
}
if (inParams.model == ModelType.CCD)
{
intamountlt = intamountl;
}
else
{
intamountlt = inParams.convertUnit(inParams.intLpSwitch, (QuantityType)inParams.intMode, QuantityType.Time, PhaseType.Lower);
}
}
if (inParams.model == ModelType.CCD)
{
pos0 = vc / inParams.uf * inParams.maxIt; // in reality [steps]
}
else
{
pos0 = vc * inParams.maxIt;
}
if (inParams.doMaxIt && maxposu > pos0)
{
maxposu = pos0;
}
if (inParams.model == ModelType.CCD)
{
pos0 = vc / inParams.lf * inParams.maxIt; // in reality [steps]
}
else
{
pos0 = vc * inParams.maxIt;
}
if (inParams.doMaxIt && maxposl > pos0)
{
maxposl = pos0;
}
// init estmax [time/steps]
previewParams.estmaxtime = 0;
previewParams.estmaxstep = 0;
// Set peaks
// *** improve int mode: loop for [intit] with inner loop for [comps]: enable compmode and time scale correction
for (int i = 0; i < ncomps; i++)
{
comp = inParams.comps[i];
outComp = outSet.comps[i];
k = comp.k;
post = 0;
// Calculate pos
if (intMode)
{
// Int mode
intit = 0;
eluted = false;
totposu = 0;
totposl = 0;
timepos = 0;
pos = injectPos;
phase = inParams.intStartPhase;
while (intit / 2 < inParams.intMaxIt && !eluted)
{
if (phase == PhaseType.Upper)
{
if (!intCompMode)
{
if (natUnits == QuantityType.Steps)
{
intAmount = intamountu;
}
else
{
intAmount = intamountut;
}
}
outCompt = calcNewPos(comp, fu, 0, vc, pos, natUnits, !intCompMode, intAmount, QuantityType.Time);
}
else
{
if (!intCompMode)
{
if (natUnits == QuantityType.Steps)
{
intAmount = intamountl;
}
else
{
intAmount = intamountlt;
}
}
outCompt = calcNewPos(comp, 0, fl, vc, pos, natUnits, !intCompMode, intAmount, QuantityType.Time);
}
eluted = outCompt.eluted;
if (!eluted)
{
post += Math.Abs(outCompt.retention - pos);
pos = outCompt.retention;
if (phase == PhaseType.Upper)
{
totposu += intamountu;
timepos += intamountut;
}
else
{
totposl += intamountl;
timepos += intamountlt;
}
// prepare for next iteration/phase
if (phase == PhaseType.Upper)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
intit++;
}
}
if (inParams.intFinalElute && !eluted)
{
// elute
if (phase == PhaseType.Upper)
{
outCompt = calcNewPos(comp, fu, 0, vc, pos, natUnits);
}
else
{
outCompt = calcNewPos(comp, fl, 0, vc, pos, natUnits);
}
eluted = outCompt.eluted;
}
if (eluted)
{
// timepos is always positive
//timepos+= inparams.convertUnit(Math::Abs(outCompt.ret),natUnits,UnitsType.Time,phase);
timepos += Math.Abs(outCompt.retentionTime);
if (timeMode)
{
// use timepos to calc pos
if (inParams.model == ModelType.CCD)
{
pos = timepos;
}
else
{
pos = inParams.convertUnit(timepos, QuantityType.Time, natUnits, phase);
}
// correct negative pos
if (phase == PhaseType.Lower)
{
pos = -Math.Abs(pos);
}
}
else if (phase == PhaseType.Upper)
{
pos = totposu + outCompt.retention0;
}
else
{
pos = -totposl + outCompt.retention0;
}
}
outComp.intIt = (float)intit / 2;
outComp.intItSet = true;
}
else
{
// Normal (not Int) mode
outCompt = calcNewPos(comp, fu, fl, vc, injectPos, natUnits, true, Math.Max(maxposu, maxposl), QuantityType.Volume);
pos = outCompt.retention;
post += Math.Abs(pos - injectPos);
timepos = Math.Abs(outCompt.retentionTime);
eluted = outCompt.eluted;
}
outComp.eluted = eluted;
outComp.outCol = eluted;
pos0 = pos;
if (!eluted && eeMode)
{
// EE mode
eeDone = true;
if (inParams.isPosEEdir())
{
eepos = inParams.convertUnit(maxposu, natUnits, inParams.viewUnits, phase);
if (!timeMode)
{
eepos += (vc - pos0);
}
else
{
eepos = 0;
}
pos = maxposu + (vc - pos0);
outCompt.phase = PhaseType.Upper;
}
else
{
eepos = inParams.convertUnit(maxposl, natUnits, inParams.viewUnits, phase);
if (!timeMode)
{
eepos += pos0;
}
else
{
eepos = 0;
}
pos = -maxposl - pos0;
outCompt.phase = PhaseType.Lower;
}
outComp.outCol = true;
}
phase = outCompt.phase;
// Calculate sigma
if (outComp.outCol || outComp.willElute)
{
// include ee outcol
timesigma = Equations.calcSigma(kdef, fnormu, fnorml, k * px, Math.Abs(timepos), mixspeed, efficiency);
if (runMode == RunModeType.DualMode)
{
timesigma *= 2;
}
if (natUnits == QuantityType.Steps)
{
// [steps]
sigma = timesigma;
}
else
{
// [volume]
if (!outComp.eluted)
{
sigma = inParams.convertColUnit(timesigma, QuantityType.Time, natUnits);
}
else
{
sigma = inParams.convertUnit(timesigma, QuantityType.Time, natUnits, phase);
}
}
if (!outComp.eluted)
{
// calc col sigma also for EE outcol
// [volume] or [steps]
sigma0 = sigma;
sigma = Equations.calcColSigma(sigma0, outCompt.retention0, post, vc);
}
if (outComp.eluted)
{
if (phase == PhaseType.Lower)
{
pos0 = pos - 3 * sigma;
if (pos0 < mindrawpos)
{
mindrawpos = pos0;
}
}
else
{
pos0 = pos + 3 * sigma;
if (pos0 > maxdrawpos)
{
maxdrawpos = pos0;
}
}
}
}
else
{
sigma = 1;
phase = PhaseType.None;
}
outComp.sigma = sigma;
outComp.phase = phase;
// set estmax [time]
if (outComp.outCol)
{
maxtime0 = Math.Abs(timepos) + 3 * timesigma;
if (maxtime0 > previewParams.estmaxtime)
{
previewParams.estmaxtime = maxtime0;
}
}
if (outComp.outCol)
{
if (outComp.eluted)
{
outComp.retention = inParams.convertUnit(Math.Abs(pos), natUnits, viewParams.viewUnits, phase);
outComp.width = inParams.convertUnit(4 * sigma, natUnits, viewParams.viewUnits, phase);
}
else
{
// not eluted but outcol (by EE)
outComp.retention = eepos;
outComp.width = 4 * sigma;
}
}
else
{
outComp.retention = inParams.convertColUnit(Math.Abs(pos), natUnits, viewParams.viewUnits);
outComp.width = inParams.convertColUnit(4 * sigma, natUnits, viewParams.viewUnits);
}
outComp.drawPosition = pos; // convert to real value later
// Calculate height
if (float.IsInfinity(k) || sigma == 0)
{
outComp.height = 1;
}
else
{
outComp.height = Equations.calcHeight(sigma); // [volume]
}
outComp.height *= comp.m;
}
// set estmax [steps]
if (inParams.doMaxIt)
{
// overwrite if maxit is set
pos0 = 0;
if (fu != 0)
{
pos0 = inParams.convertUnit(inParams.maxIt * vc, QuantityType.Volume, QuantityType.Time, PhaseType.Upper);
}
if (fl != 0)
{
pos0 = Math.Max(pos0, inParams.convertUnit(inParams.maxIt * vc, QuantityType.Volume, QuantityType.Time, PhaseType.Lower));
}
if (previewParams.estmaxtime > pos0)
{
previewParams.estmaxtime = pos0;
}
}
if (previewParams.estmaxtime == 0)
{
previewParams.estmaxtime = inParams.Tmnorm;
previewParams.estmaxstep = inParams.column;
}
else
{
if (natUnits == QuantityType.Steps)
{
// CCD mode: time units are actually step units
previewParams.estmaxstep = previewParams.estmaxtime;
}
else
{
previewParams.estmaxstep = inParams.convertUnit(previewParams.estmaxtime, QuantityType.Time, QuantityType.Steps, phase);
}
}
if (maxdrawpos == 0 && mindrawpos == 0)
{
if (inParams.doMaxIt)
{
maxdrawpos = maxposu;
mindrawpos = -maxposl;
}
}
if (eeMode)
{
if (inParams.isPosEEdir())
{
maxdrawpos += vc;
}
else
{
mindrawpos -= vc;
}
}
range = maxdrawpos - mindrawpos + vc;
// Correct drawpos
for (int i = 0; i < ncomps; i++)
{
outComp = outSet.comps[i];
pos0 = outComp.drawPosition;
if (outComp.outCol)
{
if (outComp.phase == PhaseType.Upper)
{
pos0 = maxdrawpos - pos0 + vc;
}
else
{
pos0 = mindrawpos - pos0;
}
allincol = false;
}
outComp.drawPosition = convModelToReal(pos0, mindrawpos);
}
// Set Axes
axes = outSet.axes;
axes.rangex = range; //inparams->convertUnit(drawrange,UnitsType::Time,viewparams->viewUnits,PhaseType::Up);
axes.showCol = true;
axes.colstart = convModelToReal(0, mindrawpos);
axes.colend = convModelToReal(vc, mindrawpos);
axes.scaleminulabel = 0;
axes.scalemaxulabel = inParams.convertUnit(maxdrawpos, natUnits, inParams.natUnits, PhaseType.Upper);
axes.scaleminllabel = 0;
axes.scalemaxllabel = inParams.convertUnit(-mindrawpos, natUnits, inParams.natUnits, PhaseType.Lower);
axes.scaleminu = convModelToReal(maxdrawpos + vc, mindrawpos);
axes.scalemaxu = convModelToReal(vc, mindrawpos);
axes.scaleminl = convModelToReal(mindrawpos, mindrawpos);
axes.scalemaxl = convModelToReal(0, mindrawpos);
axes.logScale = (viewParams.yScale == YScaleType.Logarithmic);
axes.update();
// init outcells
outCells = new OutCell[ncomps][];
for (int compi = 0; compi < ncomps; compi++)
{
outCells[compi] = new OutCell[nsize];
}
axes.maxcon = new List <float>(ncomps);
// Store outcells
for (int compi = 0; compi < ncomps; compi++)
{
comp = inParams.comps[compi];
outComp = outSet.comps[compi];
// Pre-calcs to improve performance
pos0 = outComp.drawPosition;
sigma = outComp.sigma;
if (sigma == 0)
{
sigma = 1;
}
amp0 = comp.m * Equations.calcHeight(sigma);
div0 = 2 * (float)Math.Pow(sigma, 2);
stepsize = range / nsize;
maxcon = 0;
for (int i = 0; i < nsize; i++)
{
pos = i * stepsize; // Real position
// make sure peak top gets drawn:
if (Math.Abs(pos - pos0) <= stepsize)
{
con = amp0;
}
else
{
con = amp0 * (float)Math.Exp(-Math.Pow(pos - pos0, 2) / div0);
}
if (con > maxcon && (outComp.outCol || allincol))
{
maxcon = con;
}
outCells[compi][i] = new OutCell(pos, con);
}
axes.maxcon.Add(maxcon);
// Correct sigma:
outComp.sigma = outComp.width / 4;
}
outSet.outCells = outCells;
return(outSet);
}
public VisOutSet updateVisOutVar(OutSet outSet, ViewParams viewParams)
{
VisOutSet visOutSet = new VisOutSet();
List <VisSerie> visSeries;
List <VisSerie> visRawSeries = null;
VisSerie visSerie;
List <VisPoint> visPoints;
OutCell[][] rawOutCells = outSet.rawOutCells;
OutCell[] compRawOutCells;
OutCell outCell;
OutComp outComp;
VisComp visComp;
VisAxes visAxes = new VisAxes();
VisAxis visAxis;
Axes axes = outSet.axes;
Axis xaxis = new Axis();
Axis yaxis = new Axis();
PhaseType phase = new PhaseType();
int nphases;
int ncomps;
int npoints;
int nseries;
int ncells;
bool previewMode = (viewParams.viewType == ViewType.Setup);
bool dispDualTime = (viewParams.phaseDisplay == PhaseDisplayType.UpperLowerTime);
bool dispDual = (viewParams.phaseDisplay == PhaseDisplayType.UpperLower || dispDualTime);
bool usePrefixes = (viewParams.exponentType == ExponentType.Prefixes);
bool scaleDrawReverse;
bool scaleSet;
bool sum;
float maxcon = 0;
float con = 0;
float rangey = 0;
float rangex = 0;
float range;
float rangey0;
float scaleu, scalel;
float miny, maxy;
float minvx = 0;
float maxvx = 0;
float minxlabel = 0;
float maxxlabel = 0;
float k;
float flow;
float pos;
float vceff;
RectangleF allrect = new RectangleF(0, 0, 1, 1);
RectangleF vrect = allrect;
RectangleF rawvrect = allrect;
float unitsize = 0.025f;
float vx, vy;
int s = 0;
int c;
string label = "";
MassUnitsType prefMassUnits = inParams.massUnits;
int prefMassUnitsi;
float multiplier = 1;
// general vars
if (dispDual && !previewMode)
{
nphases = 2;
}
else
{
nphases = 1;
}
ncomps = inParams.comps.Count;
nseries = outSet.outCells.Length;
if (ncomps == 0)
{
return(visOutSet);
}
// update outComps units
foreach (OutComp outComp0 in outSet.comps)
{
outComp0.units = inParams.viewUnits;
outComp0.volUnits = inParams.volUnits;
outComp0.timeUnits = inParams.timeUnits;
outComp0.massUnits = inParams.massUnits;
}
// convert out to units
outSet.unitsOutCells = new OutCell[outSet.outCells.Length][];
for (s = 0; s < nseries; s++)
{
c = s / nphases;
if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
ncells = outSet.outCells[s].Length;
outSet.unitsOutCells[s] = new OutCell[ncells];
for (int i = 0; i < ncells; i++)
{
pos = inParams.convertUnit(outSet.outCells[s][i].pos, inParams.natUnits, viewParams.viewUnits, phase);
con = outSet.outCells[s][i].con;
outSet.unitsOutCells[s][i] = new OutCell(pos, con);
}
}
// initialise vis series
visSeries = new List <VisSerie>(nseries);
if (viewParams.showProbUnits)
{
visRawSeries = new List <VisSerie>(nseries);
}
if (viewParams.showProbUnits)
{
if (dispDual)
{
rawvrect.Height = unitsize * 2;
}
else
{
rawvrect.Height = unitsize;
}
vrect.Y = rawvrect.Bottom;
vrect.Height = 1 - vrect.Y;
}
// Axes
axes = outSet.axes;
// Set maxcon / rangey
if (viewParams.yScale == YScaleType.Absolute)
{
// * not exactly correct; should use maxcon from first (time) step
maxcon = 0;
for (int i = 0; i < outSet.comps.Count; i++)
{
if (outSet.comps[i].m > maxcon)
{
maxcon = outSet.comps[i].m;
}
}
rangey = maxcon;
}
else if (viewParams.yScale == YScaleType.Normalised)
{
rangey = 0;
}
else // Auto or Log scale
{
maxcon = 0;
for (int i = 0; i < axes.maxcon.Count; i++)
{
if (axes.maxcon[i] > maxcon)
{
maxcon = axes.maxcon[i];
}
}
if (viewParams.yScale == YScaleType.Automatic)
{
rangey = maxcon;
}
else if (axes.logScale)
{
maxcon = (float)Math.Ceiling(Math.Log(maxcon)); // Nearest E power
rangey = 5;
// Scale: E^maxcon ... E^(maxcon-rangey)
}
}
// Column lines
if (viewParams.showProbUnits)
{
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Left, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
visAxis.point1 = new VisPoint(vrect.Right, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Top);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Top);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(vrect.Left, rawvrect.Bottom);
visAxis.point2 = new VisPoint(vrect.Right, rawvrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showCol)
{
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
vx = axes.colstart / axes.rangex * allrect.Width + allrect.Left;
visAxis.point1 = new VisPoint(vx, allrect.Top);
visAxis.point2 = new VisPoint(vx, allrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
visAxis.drawColor = Colors.LightGray;
vx = axes.colend / axes.rangex * allrect.Width + allrect.Left;
visAxis.point1 = new VisPoint(vx, allrect.Top);
visAxis.point2 = new VisPoint(vx, allrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolstart)
{
visAxis = new VisAxis();
vx = axes.deadvolstart / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolend)
{
visAxis = new VisAxis();
vx = axes.deadvolend / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
if (axes.showDeadvolinsert)
{
visAxis = new VisAxis();
vx = axes.deadvolinjectstart / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
visAxis = new VisAxis();
vx = axes.deadvolinjectend / axes.rangex * vrect.Width + vrect.Left;
visAxis.point1 = new VisPoint(vx, vrect.Top);
visAxis.point2 = new VisPoint(vx, vrect.Bottom);
visAxes.visAxes.Add(visAxis);
}
// X Axis
if (viewParams.syncScales && viewParams.viewUnits != QuantityType.ReS)
{
minxlabel = inParams.convertUnit(axes.scaleminulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
maxxlabel = inParams.convertUnit(axes.scalemaxulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
scaleu = Math.Abs(maxxlabel - minxlabel);
minxlabel = inParams.convertUnit(axes.scaleminllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
maxxlabel = inParams.convertUnit(axes.scalemaxllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
scalel = Math.Abs(maxxlabel - minxlabel);
if (scaleu != 0 && scalel != 0)
{
axes.sync(scaleu, scalel);
}
}
label = "";
for (int phasei = 0; phasei < 2; phasei++)
{
if (dispDual)
{
vy = vrect.Top + 0.5f * vrect.Height;
scaleDrawReverse = ((PhaseType)(phasei + 1) == PhaseType.Lower);
}
else
{
vy = vrect.Bottom;
scaleDrawReverse = false;
}
scaleSet = false;
if ((PhaseType)(phasei + 1) == PhaseType.Upper && (inParams.runMode != RunModeType.LowerPhase || (inParams.eeMode != EEModeType.None && inParams.isPosEEdir())) && viewParams.phaseDisplay != PhaseDisplayType.Lower)
{
// show Up axis
minvx = vrect.Left + axes.scaleminu / axes.rangexu * vrect.Width;
maxvx = vrect.Left + axes.scalemaxu / axes.rangexu * vrect.Width;
minxlabel = inParams.convertUnit(axes.scaleminulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
maxxlabel = inParams.convertUnit(axes.scalemaxulabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Upper);
rangex = Math.Abs(axes.scalemaxu - axes.scaleminu);
scaleSet = true;
}
else if ((PhaseType)(phasei + 1) == PhaseType.Lower && (inParams.runMode != RunModeType.UpperPhase || (inParams.eeMode != EEModeType.None && !inParams.isPosEEdir())) && viewParams.phaseDisplay != PhaseDisplayType.Upper)
{
// show Lp axis
minvx = vrect.Left + axes.scaleminl / axes.rangexl * vrect.Width;
maxvx = vrect.Left + axes.scalemaxl / axes.rangexl * vrect.Width;
minxlabel = inParams.convertUnit(axes.scaleminllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
maxxlabel = inParams.convertUnit(axes.scalemaxllabel, inParams.natUnits, viewParams.viewUnits, PhaseType.Lower);
rangex = Math.Abs(axes.scalemaxl - axes.scaleminl);
scaleSet = true;
}
if (scaleSet)
{
range = maxxlabel - minxlabel;
// if syncScales: use same divs/stepsize as other axis
if (phasei == 0 || !viewParams.syncScales || viewParams.phaseDisplay == PhaseDisplayType.Upper || viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
xaxis.calcScale(range);
}
if (label == "")
{
// only do first label
label = inParams.getXaxisLegend();
}
else
{
label = "";
}
visAxes.addAxis(label,
minvx, vy, maxvx, vy,
false, true, true, !previewMode, !dispDual, scaleDrawReverse, false,
false, 1,
Colors.Black, 1,
minxlabel, maxxlabel, xaxis.nMajorDivs, xaxis.majorStepSize, xaxis.nMinorDivs, xaxis.minorStepSize);
if (viewParams.viewUnits == QuantityType.ReS)
{
// ReS (K-values) scale: overwrite labels
visAxis = visAxes.visAxes[visAxes.visAxes.Count - 1];
visAxis.clearLabels();
for (int i = 0; i <= 8; i++)
{
if (i > 4)
{
k = (float)4 / (8 - i);
}
else
{
k = (float)i / 4;
}
flow = Equations.calcFlow(inParams.kDefinition, inParams.fu, -inParams.fl, k);
if (flow < 0 && inParams.runMode == RunModeType.DualMode)
{
vceff = inParams.injectPos * inParams.vc;
}
else
{
vceff = (1 - inParams.injectPos) * inParams.vc;
}
if (flow != 0)
{
if (float.IsInfinity(k))
{
pos = Equations.calcInfPos(inParams.kDefinition, vceff, inParams.lf, inParams.uf, inParams.fu, inParams.fl);
}
else
{
pos = Equations.calcPos(inParams.kDefinition, vceff, inParams.lf, inParams.uf, flow, k);
}
if ((PhaseType)(phasei + 1) == PhaseType.Lower)
{
pos = -pos;
}
pos = inParams.convertUnit(pos, QuantityType.Time, inParams.natUnits, (PhaseType)(phasei + 1));
if (pos > 0 && !float.IsInfinity(pos))
{
vx = minvx + pos / rangex * (maxvx - minvx);
visAxis.addLabel(Util.toString(k, 2), vx, vy);
}
}
}
}
}
}
// Y Axis
range = rangey;
if (!axes.logScale)
{
// normal scale
yaxis.calcScale(range);
rangey = yaxis.scale;
miny = 0;
maxy = rangey;
}
else
{
// log scale
yaxis.majorStepSize = 1;
yaxis.nMajorDivs = (int)rangey;
yaxis.minorStepSize = 0;
yaxis.nMinorDivs = 0;
miny = maxcon - rangey;
maxy = maxcon;
}
if (usePrefixes)
{
prefMassUnitsi = (int)inParams.massUnits;
rangey0 = rangey;
while (rangey0 >= 1000 && prefMassUnitsi < Enum.GetValues(typeof(MassUnitsType)).Length)
{
rangey0 /= 1000;
multiplier /= 1000;
prefMassUnitsi++;
}
while (rangey0 < 1 && prefMassUnitsi > 0)
{
rangey0 *= 1000;
multiplier *= 1000;
prefMassUnitsi--;
}
prefMassUnits = (MassUnitsType)prefMassUnitsi;
label = inParams.getYaxisLegend(prefMassUnits);
}
else
{
label = inParams.getYaxisLegend(null);
}
if (dispDual)
{
vy = vrect.Top + 0.5f * vrect.Height;
// positive y scale
visAxes.addAxis("Upper Phase " + label,
vrect.Left, vy, vrect.Left, vrect.Top,
!previewMode, true, true, !previewMode, !axes.logScale, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
// negative y scale
if (!axes.logScale)
{
yaxis.inverse();
miny = -miny;
maxy = -maxy;
}
visAxes.addAxis("Lower Phase " + label,
vrect.Left, vy, vrect.Left, vrect.Bottom,
!previewMode, true, true, !previewMode, false, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
}
else
{
visAxes.addAxis(label,
vrect.Left, vrect.Bottom, vrect.Left, vrect.Top,
!previewMode, true, true, !previewMode, true, false, axes.logScale,
!usePrefixes, multiplier,
Colors.Black, 1,
miny, maxy, yaxis.nMajorDivs, yaxis.majorStepSize, yaxis.nMinorDivs, yaxis.minorStepSize);
}
// Raw Series (units)
if (viewParams.showProbUnits)
{
for (s = 0; s < rawOutCells.Length; s++)
{
compRawOutCells = rawOutCells[s];
npoints = compRawOutCells.Length;
c = s / nphases;
visSerie = new VisSerie();
visSerie.type = VisSerieType.Units;
visSerie.visRect = new Rect(rawvrect.X, rawvrect.Y, rawvrect.Width, rawvrect.Height);
visSerie.compi = c;
visSerie.drawSize = unitsize;
visSerie.drawWeight = outSet.comps[c].m;
visPoints = new List <VisPoint>();
if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
if (phase == PhaseType.Upper)
{
rangex = axes.rangexu;
}
else
{
rangex = axes.rangexl;
}
if (c < ncomps)
{
visSerie.drawColor = Util.colorRange(c, ncomps);
}
else
{
visSerie.drawColor = Colors.Gray;
}
for (int i = 0; i < npoints; i++)
{
outCell = compRawOutCells[i];
vx = rawvrect.Left + outCell.pos / rangex * rawvrect.Width;
if (s % nphases == 0)
{
vy = rawvrect.Top;
}
else
{
vy = rawvrect.Top + 0.5f * rawvrect.Height;
}
visPoints.Add(new VisPoint(vx, vy));
}
visSerie.visPoints = visPoints.ToArray();
visRawSeries.Add(visSerie);
}
visOutSet.visRawSeries = visRawSeries.ToArray();
if (dispDual)
{
visAxis = new VisAxis();
visAxis.point1 = new VisPoint(rawvrect.Left, 0.5f * rawvrect.Height);
visAxis.point2 = new VisPoint(rawvrect.Right, 0.5f * rawvrect.Height);
visAxes.visAxes.Add(visAxis);
}
}
visOutSet.visAxes = visAxes;
// Series
if (viewParams.yScale == YScaleType.Automatic)
{
maxcon = rangey;
}
for (s = 0; s < nseries; s++)
{
npoints = outSet.outCells[s].Length;
c = s / nphases;
visSerie = new VisSerie();
visSerie.type = VisSerieType.Graph;
visSerie.visRect = new Rect(vrect.X, vrect.Y, vrect.Width, vrect.Height);
visSerie.compi = c;
visPoints = new List <VisPoint>();
if (nphases > 1)
{
phase = (PhaseType)((s % nphases) + 1);
}
else if (viewParams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (phase == PhaseType.Upper)
{
rangex = axes.rangexu;
}
else
{
rangex = axes.rangexl;
}
if (c < ncomps)
{
visSerie.drawWeight = outSet.comps[c].m;
visSerie.multiColor = false;
visSerie.drawColor = Util.colorRange(c, ncomps);
sum = false;
}
else
{
visSerie.multiColor = true;
visSerie.drawColor = Colors.Gray;
sum = true;
}
if (viewParams.peaksDisplay != PeaksDisplayType.Sum || sum)
{
// Sum graph: multi color
if (viewParams.yScale == YScaleType.Normalised)
{
maxcon = axes.maxcon[c];
}
for (int i = 0; i < npoints; i++)
{
outCell = outSet.outCells[s][i];
vx = vrect.Left + outCell.pos / rangex * vrect.Width;
if (viewParams.yScale == YScaleType.Logarithmic)
{
if (outCell.con != 0 && maxcon != 0)
{
con = (float)(1 + (Math.Log(Math.Abs(outCell.con)) - maxcon) / rangey);
if (con < 0)
{
con = 0;
}
if (outCell.con < 0)
{
con = -con;
}
}
else
{
con = 0;
}
}
else
{
if (maxcon != 0)
{
con = outCell.con / maxcon;
}
}
if (dispDual)
{
vy = vrect.Top + (1 - con) / 2 * vrect.Height;
}
else
{
vy = vrect.Bottom - con * vrect.Height;
}
if (c < ncomps)
{
visPoints.Add(new VisPoint(vx, vy));
}
else
{
visPoints.Add(new VisPoint(vx, vy, outCell.color));
}
}
visSerie.visPoints = visPoints.ToArray();
visSeries.Add(visSerie);
}
}
visOutSet.visSeries = visSeries.ToArray();
// Peaks
for (int i = 0; i < outSet.comps.Count; i++)
{
outComp = outSet.comps[i];
if (outComp.phase == PhaseType.Upper)
{
vx = vrect.Left + outComp.drawPosition / axes.rangexu * vrect.Width;
}
else if (outComp.phase == PhaseType.Lower)
{
vx = vrect.Left + outComp.drawPosition / axes.rangexl * vrect.Width;
}
else
{
vx = vrect.Left + outComp.drawPosition / axes.rangex * vrect.Width;
}
if (dispDual && outComp.phase == PhaseType.Lower)
{
vy = vrect.Bottom;
}
else
{
vy = vrect.Top;
}
visComp = new VisComp(new VisPoint(vx, vy, Util.colorRange(i, ncomps, 0.5f)), outComp.label, Util.colorRange(i, ncomps, 2));
visOutSet.comps.Add(visComp);
}
visOutSet.posUnits = inParams.getXaxisUnits();
visOutSet.useMultiplier = usePrefixes;
if (usePrefixes)
{
visOutSet.conMultiplier = multiplier;
visOutSet.conUnits = inParams.getYaxisUnits(prefMassUnits);
}
else
{
visOutSet.conMultiplier = 1;
visOutSet.conUnits = inParams.getYaxisUnits(null);
}
visOutSet.timeUnits = inParams.timeUnits.ToString();
return(visOutSet);
}
public override void storeOut(ViewParams viewParams)
{
outParams.outSet = storeOutVar(conu, conl, viewParams, false, 0);
}
private OutSet storeOutVar(List <TransCon> conu0, List <TransCon> conl0, ViewParams viewparams, bool timeMode, float time)
{
OutSet outSet = new OutSet(inParams);
TransCon compconu;
TransCon compconl;
List <List <OutCell> > outcells;
Axes axes;
int nseries;
int ncomps2;
int nphases;
int nstepsu, nstepsl, nsteps;
int ncomps = inParams.comps.Count;
int compi;
bool dispDualTime = (viewparams.phaseDisplay == PhaseDisplayType.UpperLowerTime);
bool dispDual = (viewparams.phaseDisplay == PhaseDisplayType.UpperLower || dispDualTime);
bool dispAll = (viewparams.phaseDisplay == PhaseDisplayType.All);
bool dispUP = (viewparams.phaseDisplay == PhaseDisplayType.Upper);
bool dispLP = (viewparams.phaseDisplay == PhaseDisplayType.Lower);
bool runDual = (inParams.runMode == RunModeType.DualMode || inParams.runMode == RunModeType.Intermittent);
bool runCo = (inParams.runMode == RunModeType.CoCurrent);
bool runUP = (inParams.runMode == RunModeType.UpperPhase);
bool runLP = (inParams.runMode == RunModeType.LowerPhase);
bool showCol = ((runDual && (dispAll || viewparams.phaseDisplay == PhaseDisplayType.UpperLower)) || (timeMode && !dispDualTime));
bool[] inversePhase = new bool[2];
int offsetu, offsetl, offset;
float pos;
float con, con0, maxcon;
PhaseType phase = new PhaseType();
int serie;
Color color;
float a, r, g, b;
outSet.time = time;
// inverse upper phase
inversePhase[0] = !(runLP || (runDual && (dispAll || viewparams.phaseDisplay == PhaseDisplayType.UpperLower || dispLP)));
// inverse lower phase
if (runCo || (runDual && dispDualTime))
{
inversePhase[1] = inversePhase[0];
}
else
{
inversePhase[1] = !inversePhase[0];
}
if (!showCol && !(runDual && dispDualTime))
{
// show column if non-outcol peaks inside
for (int i = 0; i < ncomps; i++)
{
if (!compEluted[i])
{
showCol = true;
}
}
}
nstepsu = 0;
nstepsl = 0;
for (compi = 0; compi < ncomps; compi++)
{
nstepsu = Math.Max(nstepsu, conu[0].Count);
nstepsl = Math.Max(nstepsl, conl[0].Count);
}
/*
* // alternative method (in case simple length can't be used)
* if (inParams->fu != 0)
* nstepsu = (runcols + 1) * columnsteps;
* else
* nstepsu = columnsteps;
* if (inParams->fl != 0)
* nstepsl = (runcols + 1) * columnsteps;
* else
* nstepsl = columnsteps;
*/
offset = 0;
if (inversePhase[0])
{
offset = nstepsu;
}
if (inversePhase[1])
{
offset = Math.Max(offset, nstepsl);
}
if (inversePhase[0])
{
offsetu = nstepsu;
}
else
{
offsetu = offset - inParams.column2;
}
if (inversePhase[1])
{
offsetl = nstepsl;
}
else
{
offsetl = offset - inParams.column2;
}
if (inversePhase[0] != inversePhase[1] && !dispUP && !dispLP)
{
nsteps = nstepsu + nstepsl - inParams.column2;
}
else
{
if (dispUP && !runLP)
{
nsteps = nstepsu;
}
else if (dispLP && !runUP)
{
nsteps = nstepsl;
}
else
{
nsteps = Math.Max(nstepsu, nstepsl);
}
}
if (!showCol)
{
nsteps -= inParams.column2;
}
if (dispDual)
{
nphases = 2;
}
else
{
nphases = 1;
}
if (viewparams.peaksDisplay == PeaksDisplayType.PeaksSum || viewparams.peaksDisplay == PeaksDisplayType.Sum)
{
ncomps2 = ncomps + 1;
}
else
{
ncomps2 = ncomps;
}
nseries = nphases * ncomps2;
// store axes
axes = outSet.axes;
axes.showCol = showCol;
if (showCol)
{
axes.colstart = offset - inParams.column2;
axes.colend = offset;
if (inParams.vdeadInEnabled)
{
axes.showDeadvolstart = true;
if (inParams.getNormalColDirection() == inversePhase[0])
{
axes.deadvolstart = axes.colstart + (inParams.column2 - inParams.getVdeadIn());
}
else
{
axes.deadvolstart = axes.colstart + inParams.getVdeadIn();
}
}
else
{
axes.showDeadvolstart = false;
}
if (inParams.vdeadOutEnabled)
{
axes.showDeadvolend = true;
if (inParams.getNormalColDirection() == inversePhase[0])
{
axes.deadvolend = axes.colstart + inParams.getVdeadOut();
}
else
{
axes.deadvolend = axes.colstart + (inParams.column2 - inParams.getVdeadOut());
}
}
else
{
axes.showDeadvolend = false;
}
if (inParams.vdeadInjectEnabled)
{
axes.showDeadvolinsert = true;
axes.deadvolinjectstart = axes.colstart + inParams.getVdeadInjectStart();
axes.deadvolinjectend = axes.colstart + inParams.getVdeadInjectEnd();
}
else
{
axes.showDeadvolinsert = false;
}
}
axes.rangex = nsteps;
if (axes.rangex == 0)
{
axes.rangex = 1; // prevent div by zero
}
axes.scaleminulabel = 0;
axes.scalemaxulabel = nstepsu - inParams.column2;
axes.scaleminllabel = 0;
axes.scalemaxllabel = nstepsl - inParams.column2;
if (inversePhase[0])
{
axes.scaleminu = 0;
axes.scalemaxu = nstepsu - inParams.column2;
}
else
{
axes.scaleminu = nsteps;
axes.scalemaxu = offset;
}
if (inversePhase[1])
{
axes.scaleminl = 0;
axes.scalemaxl = nstepsl - inParams.column2;
}
else
{
axes.scaleminl = nsteps;
axes.scalemaxl = offset;
}
axes.logScale = (viewparams.yScale == YScaleType.Logarithmic);
axes.update();
axes.maxcon = new List <float>(ncomps);
// store peaks
outSet.comps = storePeaks(conu0, conl0, offsetu, offsetl, inversePhase, axes, viewparams, showCol);
// init outcells
outcells = new List <List <OutCell> >(nseries);
for (int i = 0; i < nseries; i++)
{
outcells.Add(new List <OutCell>(nsteps));
}
for (compi = 0; compi < ncomps; compi++)
{
for (int phasei = 0; phasei < nphases; phasei++)
{
serie = compi * nphases + phasei;
compconu = conu0[compi];
compconl = conl0[compi];
maxcon = 0;
for (int i = 0; i < nsteps; i++)
{
pos = i;
con = 0;
if (nphases > 1)
{
phase = (PhaseType)(phasei + 1);
}
else if (viewparams.phaseDisplay == PhaseDisplayType.Lower)
{
phase = PhaseType.Lower;
}
else
{
phase = PhaseType.Upper;
}
if (phase == PhaseType.Upper || dispAll)
{
con += compconu.getNormCon(i, offsetu, inversePhase[0]);
}
if (phase == PhaseType.Lower || dispAll)
{
con += compconl.getNormCon(i, offsetl, inversePhase[1]);
}
if (con > maxcon)
{
maxcon = con;
}
if (dispDual && (PhaseType)(phasei + 1) == PhaseType.Lower)
{
con = -con;
}
outcells[serie].Add(new OutCell(pos, con));
}
axes.maxcon.Add(maxcon);
}
}
color = new Color();
if (viewparams.peaksDisplay == PeaksDisplayType.PeaksSum || viewparams.peaksDisplay == PeaksDisplayType.Sum)
{
// add series for sum
for (int i = 0; i < nsteps; i++)
{
pos = i;
maxcon = 0;
for (int phasei = 0; phasei < nphases; phasei++)
{
con = 0;
a = 0;
r = 0;
g = 0;
b = 0;
for (compi = 0; compi < ncomps; compi++)
{
serie = compi * nphases + phasei;
con0 = outcells[serie][i].con;
con += con0;
color = Util.colorRange(compi, ncomps);
r += color.ScR * Math.Abs(con0);
g += color.ScG * Math.Abs(con0);
b += color.ScB * Math.Abs(con0);
}
if (con != 0)
{
a = 1;
r /= Math.Abs(con);
g /= Math.Abs(con);
b /= Math.Abs(con);
}
compi = ncomps;
serie = ncomps * nphases + phasei;
if (Math.Abs(con) > maxcon)
{
maxcon = Math.Abs(con);
}
outcells[serie].Add(new OutCell(pos, con, Color.FromScRgb(a, r, g, b)));
}
axes.maxcon.Add(maxcon);
}
}
// convert List to array
outSet.outCells = new OutCell[outcells.Count][];
for (int i = 0; i < outcells.Count; i++)
{
outSet.outCells[i] = new OutCell[outcells[i].Count];
for (int j = 0; j < outcells[i].Count; j++)
{
outSet.outCells[i][j] = outcells[i][j];
}
}
return(outSet);
}
private List <OutComp> storePeaks(List <TransCon> conu0, List <TransCon> conl0, int offsetu0, int offsetl0, bool[] inversePhase, Axes axes, ViewParams viewparams, bool showCol)
{
List <OutComp> outComps = new List <OutComp>();
OutComp outComp;
TransCon compconu;
TransCon compconl;
int ncomps = inParams.comps.Count;
float cu, cl;
float con, maxcon;
float pos, normpos, realpos;
float width, hwidth, swidth;
float sumavg, avg;
float normavg, realavg;
float totm, totmup, totmlp;
bool up;
int nsteps;
int offsetu = 0;
int offsetl = 0;
bool inverseu, inversel;
float contarget, conother, conall;
float purity;
float recovery;
if (inParams.runMode == RunModeType.CoCurrent)
{
inverseu = false;
inversel = false;
offsetu = 0;
offsetl = 0;
}
else
{
inverseu = false;
inversel = true;
}
for (int compi = 0; compi < ncomps; compi++)
{
compconu = conu0[compi];
compconl = conl0[compi];
nsteps = compconu.Count + compconl.Count - inParams.column2;
if (inParams.runMode != RunModeType.CoCurrent)
{
offsetu = compconl.Count - inParams.column2;
offsetl = compconl.Count;
}
pos = 0;
maxcon = 0;
normpos = 0;
up = false;
for (int i = 0; i < nsteps; i++)
{
cu = compconu.getNormCon(i, offsetu, inverseu);
cl = compconl.getNormCon(i, offsetl, inversel);
con = cu + cl;
if (con > maxcon)
{
maxcon = con;
normpos = i;
up = (cu > cl);
}
}
hwidth = calcHeightWidth(compconu, compconl, offsetu, offsetl, inverseu, inversel, nsteps, normpos, maxcon);
swidth = calcSlopeWidth(compconu, compconl, offsetu, offsetl, inverseu, inversel, nsteps, normpos);
width = Equations.calcBestWidth(hwidth, swidth);
// totm + avg
totm = 0;
totmup = 0;
totmlp = 0;
sumavg = 0;
for (int i = 0; i < nsteps; i++)
{
cu = compconu.getNorm(i, offsetu, inverseu);
cl = compconl.getNorm(i, offsetl, inversel);
//if (inParams->runMode == RunMode::Co && i >= inParams->column2) {
// correct cu, cl ?
//}
con = cu + cl;
sumavg += (i * con);
totm += con;
totmup += cu;
totmlp += cl;
}
normavg = sumavg / totm;
// purity
contarget = 0;
conall = 0;
for (int i = 0; i < nsteps; i++)
{
cu = compconu.getNorm(i, offsetu, inverseu);
cl = compconl.getNorm(i, offsetl, inversel);
con = cu + cl;
if (con > mincon)
{
// target component present
contarget += con;
for (int c = 0; c < ncomps; c++)
{
cu = conu0[c].getNorm(i, offsetu, inverseu);
cl = conl0[c].getNorm(i, offsetl, inversel);
con = cu + cl;
conall += con;
}
}
}
purity = contarget / conall;
// recovery
contarget = 0;
for (int i = 0; i < nsteps; i++)
{
conother = 0;
for (int c = 0; c < ncomps; c++)
{
if (c != compi)
{
cu = conu0[c].getNorm(i, offsetu, inverseu);
cl = conl0[c].getNorm(i, offsetl, inversel);
con = cu + cl;
conother += con;
}
}
if (conother < mincon)
{
cu = compconu.getNorm(i, offsetu, inverseu);
cl = compconl.getNorm(i, offsetl, inversel);
con = cu + cl;
contarget += con;
}
}
recovery = contarget;
outComp = new OutComp(inParams.comps[compi]);
outComp.height = maxcon;
outComp.totm = totm;
outComp.totmup = totmup;
outComp.totmlp = totmlp;
outComp.purity = purity;
outComp.recovery = recovery;
if (up)
{
outComp.phase = PhaseType.Upper;
// convert norm back to model
pos = compconu.convNormToModel((int)normpos, offsetu, inverseu);
avg = compconu.convNormToModel((int)normavg, offsetu, inverseu);
// convert normal position back into screen position (using out/draw params):
outComp.drawPosition = compconu.convModelToNorm((int)pos, offsetu0, inversePhase[0]);
// convert position to retention
realpos = compconu.Count - pos;
realavg = compconu.Count - avg;
}
else
{
outComp.phase = PhaseType.Lower;
// convert norm back to model
pos = compconl.convNormToModel((int)normpos, offsetl, inversel);
avg = compconl.convNormToModel((int)normavg, offsetl, inversel);
// convert normal position back into screen position (using out/draw params):
outComp.drawPosition = compconl.convModelToNorm((int)pos, offsetl0, inversePhase[1]);
// convert position to retention
realpos = compconl.Count - pos;
realavg = compconl.Count - avg;
}
outComp.outCol = (pos > inParams.column2);
outComp.eluted = outComp.outCol;
if (!outComp.eluted)
{
// if not eluted; redo position calc depending on point of insertion
outComp.phase = PhaseType.None;
// if (inParams->runMode != RunMode::Lp) {
pos = compconu.convNormToModel((int)normpos, offsetu, inverseu);
avg = compconu.convNormToModel((int)normavg, offsetu, inverseu);
// } else {
// pos = compconl.convNormToModel((int)normpos,offsetl,inversel);
// avg = compconl.convNormToModel((int)normavg,offsetl,inversel);
// }
}
if (outComp.eluted)
{
outComp.retention = inParams.convertUnit(realpos, inParams.natUnits, viewparams.viewUnits, outComp.phase);
outComp.average = inParams.convertUnit(realavg, inParams.natUnits, viewparams.viewUnits, outComp.phase);
outComp.width = inParams.convertUnit(width, inParams.natUnits, viewparams.viewUnits, outComp.phase);
outComp.hwidth = inParams.convertUnit(hwidth, inParams.natUnits, viewparams.viewUnits, outComp.phase);
outComp.swidth = inParams.convertUnit(swidth, inParams.natUnits, viewparams.viewUnits, outComp.phase);
}
else
{
// if not outcol: overwrite with column value
outComp.retention = inParams.convertColUnit(pos, inParams.natUnits, viewparams.viewUnits);
outComp.average = inParams.convertColUnit(avg, inParams.natUnits, viewparams.viewUnits);
outComp.width = inParams.convertColUnit(width, inParams.natUnits, viewparams.viewUnits);
outComp.hwidth = inParams.convertColUnit(hwidth, inParams.natUnits, viewparams.viewUnits);
outComp.swidth = inParams.convertColUnit(swidth, inParams.natUnits, viewparams.viewUnits);
outComp.phase = PhaseType.None;
}
outComp.sigma = outComp.width / 4;
outComps.Add(outComp);
}
return(outComps);
}
public void updateVisOut(ViewParams viewParams)
{
outParams.visOutSet = updateVisOutVar(outParams.outSet, viewParams);
}
public void writeOut(string fileName, ViewParams viewParams, OutCell[][] outCells)
{
TextWriter file;
string unitsLabel = "";
string label;
string addlabel;
int nphases;
int ncomps;
int nseries;
float minpos, maxpos;
bool dispDual = (viewParams.phaseDisplay == PhaseDisplayType.UpperLower || viewParams.phaseDisplay == PhaseDisplayType.UpperLowerTime);
QuantityType viewUnits = viewParams.viewUnits;
bool done;
bool sepPos = false;
int i;
if (viewUnits == QuantityType.ReS)
{
viewUnits = QuantityType.Volume;
}
if (dispDual)
{
nphases = 2;
}
else
{
nphases = 1;
}
ncomps = inParams.comps.Count;
if (viewParams.peaksDisplay != PeaksDisplayType.Peaks)
{
ncomps++;
}
nseries = ncomps * nphases;
if (viewUnits == QuantityType.Steps)
{
unitsLabel = "Step";
}
else if (viewUnits == QuantityType.Volume)
{
unitsLabel = "Volume";
}
else if (viewUnits == QuantityType.Time)
{
unitsLabel = "Time";
}
else if (viewUnits == QuantityType.ReS)
{
unitsLabel = "ReS";
}
// check if all pos ranges are the same
minpos = outCells[0][0].pos;
maxpos = outCells[0][outCells[0].Length - 1].pos;
for (int serie = 0; serie < outCells.Length; serie++)
{
if (outCells[serie][0].pos != minpos || outCells[serie][outCells[serie].Length - 1].pos != maxpos)
{
sepPos = true;
}
}
file = new StreamWriter(fileName);
// labels
for (int c = 0; c < ncomps; c++)
{
if (c < inParams.comps.Count)
{
label = inParams.comps[c].label;
}
else
{
label = "Sum";
}
for (i = 0; i < nphases; i++)
{
if (nphases > 1 && (PhaseType)(i + 1) == PhaseType.Upper)
{
addlabel = "(UP)";
}
else if (nphases > 1 && (PhaseType)(i + 1) == PhaseType.Lower)
{
addlabel = "(LP)";
}
else
{
addlabel = "";
}
if (sepPos || (c == 0 && i == 0))
{
file.Write(unitsLabel);
file.Write(",");
}
file.Write(label + addlabel);
if (i + 1 < nphases)
{
file.Write(",");
}
}
if (c + 1 < ncomps)
{
file.Write(",");
}
}
file.WriteLine();
// data
i = 0;
done = false;
while (!done)
{
done = true;
for (int serie = 0; serie < outCells.Length; serie++)
{
if (i < outCells[serie].Length)
{
if (sepPos || serie == 0)
{
file.Write(string.Format(CultureInfo.InvariantCulture, "{0},", outCells[serie][i].pos));
}
file.Write(string.Format(CultureInfo.InvariantCulture, "{0}", outCells[serie][i].con));
if (serie + 1 < outCells.Length)
{
file.Write(",");
}
done = false;
}
else
{
// insert spacers
if (sepPos || serie == 0)
{
file.Write(",");
}
if (serie + 1 < outCells.Length)
{
file.Write(",");
}
}
}
file.WriteLine();
i++;
}
file.Close();
}
public override void storeTimeOut(ViewParams viewparams)
{
// Dummy; never used
}
public abstract void writeData(string fileName, ViewParams viewParams, int timei);
public abstract void updatePreview(InParamsExt inParams, ViewParams viewParams, OptionParams optionParams);
public void writeOutRaw(string fileName, ViewParams viewParams, InParamsExt inParams, OutParams outParams)
{
// *** obsolete; can re-use writeOut instead?
TextWriter file;
OutCell[][] rawOutCells;
string unitsLabel = "";
string label;
string addlabel;
int nphases;
int ncomps;
int nseries;
int ncells;
bool dispDual = (viewParams.phaseDisplay == PhaseDisplayType.UpperLower);
bool first;
if (dispDual)
{
nphases = 2;
}
else
{
nphases = 1;
}
ncomps = inParams.comps.Count;
if (viewParams.peaksDisplay != PeaksDisplayType.Peaks)
{
ncomps++;
}
nseries = ncomps * nphases;
if (inParams.natUnits == QuantityType.Steps)
{
unitsLabel = "Step";
}
else if (inParams.natUnits == QuantityType.Volume)
{
unitsLabel = "Volume";
}
else if (inParams.natUnits == QuantityType.Time)
{
unitsLabel = "Time";
}
else if (inParams.natUnits == QuantityType.ReS)
{
unitsLabel = "ReS";
}
file = new StreamWriter(fileName);
// labels
first = true;
for (int c = 0; c < ncomps; c++)
{
if (c < inParams.comps.Count)
{
label = inParams.comps[c].label;
}
else
{
label = "Sum";
}
for (int i = 0; i < nphases; i++)
{
if (!first)
{
file.Write(",");
}
file.Write(unitsLabel);
file.Write(",");
if (nphases > 1 && (PhaseType)(i + 1) == PhaseType.Upper)
{
addlabel = "(UP)";
}
else if (nphases > 1 && (PhaseType)(i + 1) == PhaseType.Lower)
{
addlabel = "(LP)";
}
else
{
addlabel = "";
}
file.Write(label + addlabel);
first = false;
}
}
file.WriteLine();
// data
rawOutCells = outParams.outSet.rawOutCells;
ncells = rawOutCells[0].Length;
for (int i = 0; i < ncells; i++)
{
first = true;
for (int s = 0; s < nseries; s++)
{
if (!first)
{
file.Write(",");
}
file.Write(string.Format(CultureInfo.InvariantCulture, "{0},{1}", rawOutCells[s][i].pos, rawOutCells[s][i].con));
first = false;
}
file.WriteLine();
}
file.Close();
}
public override void storeOut(ViewParams viewParams)
{
previewParams.outSet = storeOutVar(viewParams);
}
