示例#1
0
        public string getText(int timei = -1)
        {
            List <OutComp> outcomps;
            string         s = "";

            if (timei >= 0)
            {
                outcomps = timeOutSet[timei].comps;
            }
            else
            {
                outcomps = outSet.comps;
            }

            if (outcomps.Count > 0)
            {
                OutComp prevComp = null;
                float   rs       = 0;

                ControlComp comp0 = new ControlComp(outcomps[0]);

                s += "<b>Label\tK\tM\tCon\tPhase\tRet (max)\tRet (avg)\tWidth\tSigma\tHeight\tPurity\tRecovery\tResolution</b>\n";
                s += string.Format("<b>\t\t{0}\t{1}\t\t{2}\t{2}\t{2}\t{2}\t{1}\t\t\t</b>\n",
                                   comp0.MassUnits, comp0.ConcentrationUnits, comp0.Units, comp0.Units, comp0.Units);

                foreach (OutComp comp in outcomps)
                {
                    s += comp.label + "\t";
                    s += string.Format("{0}\t", comp.k);
                    s += string.Format("{0}\t", comp.m);
                    s += string.Format("{0:0.0#E+0}\t", comp.concentration);
                    s += string.Format("{0}\t", comp.phase);
                    s += string.Format("{0:0.0#}\t", comp.retention);
                    s += string.Format("{0:0.0#}\t", comp.average);
                    s += string.Format("{0:0.0#}\t", comp.width);
                    s += string.Format("{0:0.0#}\t", comp.sigma);
                    s += string.Format("{0:0.0#E+0}\t", comp.height);
                    s += string.Format("{0:0.0%}\t", comp.purity);
                    s += string.Format("{0:0.0%}\t", comp.recovery);

                    if (prevComp != null)
                    {
                        rs = Equations.calcRes(prevComp, comp);
                        if (rs != 0)
                        {
                            s += string.Format("{0:0.000#}", rs);
                        }
                        else
                        {
                            s += "-";
                        }
                    }

                    s += "\n";

                    prevComp = comp;
                }
            }
            return(s);
        }
示例#2
0
        public void updateControlComp()
        {
            float sel = comp1.k / comp2.k;
            float rs  = Equations.calcRes(comp1, comp2);

            labelText.Text = String.Format("{0}, {1}", comp1.label, comp2.label);
            kText.Text     = String.Format("{0}, {1}", comp1.k, comp2.k);
            selText.Text   = String.Format("{0:0.000}", sel);
            if (rs != 0)
            {
                rsText.Text = String.Format("{0:0.000}", rs);
            }
            else
            {
                rsText.Text = "-";
            }
        }
示例#3
0
文件: Model.cs 项目: folterj/ProMISE2
        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);
        }
示例#4
0
        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);
        }
示例#5
0
        private void inject()
        {
            Comp  comp;
            float feedtime = 0;
            float compm;
            float fu;
            float fl;
            int   insposu;
            int   insposl;
            float tmnorm = inParams.Tmnorm;
            bool  first  = (it == 0);

            insposu = (int)inParams.getInjectPosNorm();
            if (inParams.runMode == RunModeType.CoCurrent)
            {
                insposl = insposu;
            }
            else
            {
                insposl = inParams.column2 - 1 - insposu;
            }

            if (inParams.injectMode == InjectModeType.Instant)
            {
                if (!first)
                {
                    return;
                }
            }
            else
            {
                feedtime = inParams.convertUnit(inParams.injectFeed, inParams.injectFeedUnits, QuantityType.Time, inParams.injectPhase);
            }

            for (int compi = 0; compi < inParams.comps.Count; compi++)
            {
                comp = inParams.comps[compi];
                if (inParams.injectMode == InjectModeType.Instant)
                {
                    compm = comp.m;
                }
                else if (inParams.injectMode == InjectModeType.Continuous)
                {
                    compm = comp.concentration;
                }
                else
                {
                    compm = comp.m / feedtime * dtreal;
                    if (compm > compTotMass[compi])
                    {
                        compm = compTotMass[compi];
                    }
                }
                if (compTotMass[compi] > 0 || inParams.injectMode == InjectModeType.Continuous)
                {
                    if (inParams.injectPhase == PhaseType.Upper)
                    {
                        conu[compi][insposu] += compm;
                    }
                    else if (inParams.injectPhase == PhaseType.Lower)
                    {
                        conl[compi][insposl] += compm;
                    }
                    else
                    {
                        // make sure to have 'perfect' distribution if sample is inserted in both phases
                        fu = Equations.calcTransferU(inParams.kDefinition, comp.k * inParams.px);
                        fl = Equations.calcTransferL(inParams.kDefinition, comp.k * inParams.px);
                        conu[compi][insposu] += fu * compm;
                        conl[compi][insposl] += fl * compm;
                    }
                    compTotMass[compi] -= compm;
                }
            }
        }
示例#6
0
        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);
        }
示例#7
0
        public float convertColUnit(float val0, QuantityType srcUnits, QuantityType dstUnits)
        {
            float val  = val0;
            float tm   = 0;
            float flow = 0;

            if (dstUnits == srcUnits)
            {
                return(val);
            }

            flow = fu + fl;
            tm   = vc / flow;

            if (model == ModelType.Transport)
            {
                if (srcUnits == QuantityType.Steps && dstUnits == QuantityType.Volume)
                {
                    val *= (vc / column);
                    return(val);
                }
                else if (srcUnits == QuantityType.Volume && dstUnits == QuantityType.Steps)
                {
                    val *= (column / vc);
                    return(val);
                }

                // x -> time
                switch (srcUnits)
                {
                case QuantityType.Steps:
                    val *= (tm / column);
                    break;

                case QuantityType.Volume:
                    val /= flow;
                    break;
                }
                // time -> y
                switch (dstUnits)
                {
                case QuantityType.Steps:
                    val /= (tm / column);
                    break;

                case QuantityType.Volume:
                    val *= flow;
                    break;

                case QuantityType.Column:
                    val /= tm;
                    break;

                case QuantityType.ReS:
                    val = Equations.calcK(kDefinition, vu, vl, fu, fl, val * flow);
                    break;
                }
            }
            else
            {
                // x -> vol
                switch (srcUnits)
                {
                case QuantityType.Steps:
                    val *= (vc / column);
                    break;

                case QuantityType.Time:
                    val *= flow;
                    break;
                }
                // vol -> y
                switch (dstUnits)
                {
                case QuantityType.Steps:
                    val /= (vc / column);
                    break;

                case QuantityType.Time:
                    val /= flow;
                    break;

                case QuantityType.Column:
                    val /= vc;
                    break;

                case QuantityType.ReS:
                    val = Equations.calcK(kDefinition, vu, vl, fu, fl, val);
                    break;
                }
            }
            return(val);
        }
示例#8
0
        public float convertUnit(float val0, QuantityType srcUnits, QuantityType dstUnits, PhaseType phase)
        {
            float val  = val0;
            float vm0  = 0;
            float vm   = 0;
            float tm   = 0;
            float flow = 0;

            if (dstUnits == srcUnits)
            {
                return(val);
            }

            if (phase == PhaseType.Upper || phase == PhaseType.Both || runMode == RunModeType.CoCurrent)
            {
                vm0  += vu;
                vm   += vu * fnormu;
                flow += fu;
                if (fu != 0)
                {
                    tm += vu / fu;
                }
            }
            if (phase == PhaseType.Lower || phase == PhaseType.Both || runMode == RunModeType.CoCurrent)
            {
                vm0  += vl;
                vm   += vl * fnorml;
                flow += fl;
                if (fl != 0)
                {
                    tm += vl / fl;
                }
            }

            if (model == ModelType.Transport)
            {
                if (runMode == RunModeType.CoCurrent)
                {
                    tm = Tmnorm;
                }
                // x -> time
                switch (srcUnits)
                {
                case QuantityType.Steps:
                    val *= (tm / column);
                    break;

                case QuantityType.Volume:
                    val /= flow;
                    break;
                }
                tm = Tmnorm;
                // time -> y
                switch (dstUnits)
                {
                case QuantityType.Steps:
                    val /= (tm / column);
                    break;

                case QuantityType.Volume:
                    val *= flow;
                    break;

                case QuantityType.Column:
                    val /= tm;
                    break;

                case QuantityType.ReS:
                    val = Equations.calcK(kDefinition, vu, vl, fu, fl, val * flow);
                    break;
                }
            }
            else
            {
                // x -> vol
                switch (srcUnits)
                {
                case QuantityType.Steps:
                    val *= (vm / column);
                    break;

                case QuantityType.Time:
                    val *= flow;
                    break;
                }
                // vol -> y
                switch (dstUnits)
                {
                case QuantityType.Steps:
                    val /= (vm / column);
                    break;

                case QuantityType.Time:
                    val /= flow;
                    break;

                case QuantityType.Column:
                    val /= vm0;
                    break;

                case QuantityType.ReS:
                    val = Equations.calcK(kDefinition, vu, vl, fu, fl, val);
                    break;
                }
            }
            return(val);
        }
示例#9
0
        public OutComp calcNewPos(Comp comp, float fu, float fl, float vc, float pos0, QuantityType natUnits, bool limit, float maxpos, QuantityType limitUnits)
        {
            OutComp   outcomp = new OutComp();
            float     flow;
            float     ret;
            float     rettime;
            float     vceff;
            PhaseType phase = new PhaseType();
            float     elutable;
            float     lf   = inParams.lf;
            float     uf   = inParams.uf;
            float     px   = inParams.px;
            KdefType  kdef = inParams.kDefinition;
            float     k    = comp.k;

            // * flow
            if (natUnits == QuantityType.Steps)
            {
                flow = Equations.calcStepFlow(kdef, lf, uf, fu, fl, k);
            }
            else
            {
                flow = Equations.calcFlow(kdef, fu, fl, k);
            }

            if (inParams.runMode != RunModeType.CoCurrent)
            {
                elutable = Equations.calcElutable(kdef, fu, -fl, k);
            }
            else
            {
                elutable = Equations.calcElutable(kdef, fu, fl, k);
            }

            if (elutable > 0.01)
            {
                // will elute
                // * vceff
                if (flow < 0)
                {
                    vceff = pos0;
                }
                else
                {
                    vceff = vc - pos0;
                }
                // * ret
                // [time]
                rettime = Equations.calcPos(kdef, vceff, lf, uf, flow, k);
                outcomp.retentionTime = rettime;
                if (rettime < 0)
                {
                    phase = PhaseType.Lower;
                }
                else
                {
                    phase = PhaseType.Upper;
                }

                if (natUnits == QuantityType.Steps)
                {
                    // [steps]
                    ret = rettime;
                }
                else
                {
                    // [volume] or [time]
                    ret = inParams.convertUnit(rettime, QuantityType.Time, natUnits, phase);
                }
                outcomp.retention0 = ret;
                // * new pos
                if (limit && (Math.Abs(rettime) > maxpos && limitUnits == QuantityType.Time || Math.Abs(ret) > maxpos && limitUnits != QuantityType.Time))
                {
                    // [volume] or [steps]
                    outcomp.retention = pos0 + Equations.calcColPos(kdef, maxpos, lf, uf, flow, k);
                    outcomp.eluted    = false;
                }
                else
                {
                    outcomp.retention = ret;
                    outcomp.eluted    = true;
                }
            }
            else
            {
                outcomp.retention = pos0;
                if (flow < 0)
                {
                    phase = PhaseType.Lower;
                }
                else
                {
                    phase = PhaseType.Upper;
                }
            }
            outcomp.phase = phase;
            return(outcomp);
        }
示例#10
0
        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);
        }