public Model(Protocol prt, double pCCH, double pCFeH, double pCMnH, double pCSiH, double pCOH, double pCFeOH, double pCMnOH, double pCSiO2H, double pCCaOH)
{
_calc = new Calculation();
_cur = new Currents();
_cur.CC = pCCH;
_cur.CMn = pCMnH;
_cur.CSi = pCSiH;
_cur.CO = pCOH;
_cur.CFeO = pCFeOH;
_cur.CMnO = pCMnOH;
_cur.CSiO2 = pCSiO2H;
_cur.CCaO = pCCaOH;
_cur.mC = _cur.CC * prt.mStH / 100;
_cur.mFe = pCFeH * prt.mStH / 100;
_cur.mMn = _cur.CMn * prt.mStH / 100;
_cur.mSi = _cur.CSi * prt.mStH / 100;
_cur.mO = _cur.CO * prt.mStH / 100;
_cur.mFeO = _cur.CFeO * prt.mSlH / 100;
_cur.mMnO = _cur.CMnO * prt.mSlH / 100;
_cur.mSiO2 = _cur.CSiO2 * prt.mSlH / 100;
_cur.mCaO = _cur.CCaO * prt.mSlH / 100;
_cur.mSt = prt.mStH;
_cur.mSl = prt.mSlH;
_cur.Tav = prt.TH;
_cur.EScrS = prt.WCh1SP;
_cur.ECPh = _calc.ECPh_0(prt);
_cur.mStL = 0;
_cur.mStLPrev = 0;
}
public Currents GetMainParamsHeat(Protocol prt)
{
_cur.mStLPrev = _cur.mStL;
GetConsumption(prt);
GetMasses(prt);
_cur.EScrS = _calc.EScrS(prt, _cur);
_cur.ECPh = _calc.ECPh(prt, _cur);
var TavAUX = _cur.Tav;
while (TavAUX - _cur.Tav > 0 && TavAUX - _cur.Tav < 2)
{
TavAUX = _calc.Tav(prt, _cur);
GetMasses(prt);
_cur.EScrS = _calc.EScrS(prt, _cur);
_cur.ECPh = _calc.ECPh(prt, _cur);
_cur.mStLPrev = _cur.mStL;
_cur.mStL = _calc.mStL(_cur);
_cur.CC = _calc.CC(prt, _cur);
_cur.CMn = _calc.CMn(prt, _cur);
_cur.CSi = _calc.CSi(prt, _cur);
_cur.CO = _calc.CO(prt, _cur);
_cur.CFeO = _calc.CFeO(prt, _cur);
_cur.CMnO = _calc.CMnO(prt, _cur);
_cur.CSiO2 = _calc.CSiO2(prt, _cur);
_cur.CCaO = _calc.CCaO(prt, _cur);
_cur.Tav = _calc.Tav(prt, _cur);
}
return _cur;
}
/// <summary>
/// Масса углерода в металле, кг
/// mC(i)=mC(i-1)+(nRedPC(i)-nOxRC(i)-nOxLC(i))*muC*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mC(Protocol prt, Currents cur)
{
return cur.mC + (nRedPC(prt, cur) - nOxRC(prt, cur) - nOxLC(prt, cur)) * Constants.muC * prt.dt;
}
//расчитываем текущие расходы
private void GetConsumption(Protocol prt)
{
_cur.CnsEE = prt.We > 0 ? _calc.CnsEE(prt, _cur) : _cur.CnsEE;
_cur.CnsCH4 = prt.UCH4B + prt.UCH4RB > 0 ? _calc.CnsCH4(prt, _cur) : _cur.CnsCH4;
_cur.CnsO2B = prt.UO2B + prt.UO2RB > 0 ? _calc.CnsO2B(prt, _cur) : _cur.CnsO2B;
_cur.CnsO2L = prt.UO2L + prt.UO2RL > 0 ? _calc.CnsO2L(prt, _cur) : _cur.CnsO2L;
_cur.CnsCP = prt.mCP > 0 ? _calc.CnsCP(prt, _cur) : _cur.CnsCP;
_cur.CnsCk = prt.mCkAdd > 0 ? _calc.CnsCk(prt, _cur) : _cur.CnsCk;
_cur.CnsDlmt = prt.mDlmtAdd > 0 ? _calc.CnsDlmt(prt, _cur) : _cur.CnsDlmt;
_cur.CnsLm = prt.mLmAdd > 0 ? _calc.CnsLm(prt, _cur) : _cur.CnsLm;
_cur.CnsHI = prt.mHI > 0 ? _calc.CnsHI(prt, _cur) : _cur.CnsHI;
_cur.CnsScr = prt.mCh1 + prt.mCh2S > 0 ? _calc.CnsScr(prt, _cur) : _cur.CnsScr;
}
/// <summary>
/// Расход кокса, кг
/// CnsCk(i)=CnsCk(i-1)+mCk(i)*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CnsCk(Protocol prt, Currents cur)
{
return cur.CnsCk + mCk(prt) * prt.dt;
}
/// <summary>
/// Концентрация MnO в шлаке, % масс
/// CMnO(i)=mMnO(i)/mSl(i)*100
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CMnO(Protocol prt, Currents cur)
{
return cur.mMnO / cur.mSl * 100;
}
/// <summary>
/// Средняя температура системы металл-шлак, К
/// при средней температуре металла менее температуры ликвидус
/// при ECPh(i)-cSl*Tav(i-1)*mSl(i) меньше или = (EStL*mSt(i)-lmbdSt*mSt(i))
/// Tav(i)=(ECPh(i)+cStS*mSt(i)*Tenv(i))/(cStS*mSt(i)+cSl*mSl(i))
/// при средней температуре металла равной температуре ликвидус
/// при ECPh(i)-cSl*Tav(i)*mSl(i) меньше или = EStL*mSt(i)
/// Tav(i)=TStL
/// при средней температуре металла более температуры ликвидус
/// в остальных случаях:
/// Tav(i)=(ECPh(i)-mSt(i)*(cStS*TStL-cStS*Tenv(i)-cStL*TStL+lmbdSt))/(cStL*mSt(i)+cSl*mSl(i))
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double Tav(Protocol prt, Currents cur)
{
var ttemp1 = cur.ECPh - Constants.cSl * cur.Tav * cur.mSt;
var ttemp2 = (Constants.EStL * cur.mSt - Constants.lmbdSt * cur.mSt);
var ttemp3 = Constants.EStL * cur.mSt;
if (ttemp1 <= ttemp2)
{
return (cur.ECPh + Constants.cStS * cur.mSt * prt.Tenv) /
(Constants.cStS * cur.mSt + Constants.cSl * cur.mSl);
}
if (ttemp1 <= ttemp3)
{
return Constants.TStL;
}
return (cur.ECPh - cur.mSt *
(Constants.cStS*Constants.TStL - Constants.cStS*prt.Tenv - Constants.cStL*Constants.TStL +
Constants.lmbdSt)) / (Constants.cStL * cur.mSt + Constants.cSl * cur.mSl);
}
/// <summary>
/// Масса разовой порции шлакообразующих материалов в загрузочном бункере, кг
/// mSlAdd=mLmAdd+mDlmtAdd
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <returns></returns>
public double mSlAdd(Protocol prt)
{
return prt.mLmAdd + prt.mDlmtAdd;
}
/// <summary>
/// Интенсивность образования отходящих газов при работе горелки, кг/с
/// mOffGB(i)=mOffCO2B(i)+mOffH2OB(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <returns></returns>
public double mOffGB(Protocol prt)
{
return mOffCO2B(prt) + mOffH2OB(prt);
}
/// <summary>
/// Масса кислорода в металле, кг
/// mO(i)=mO(i-1)+(mSolOR(i)+mSolOL(i))*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mO(Protocol prt, Currents cur)
{
return cur.mO + (mSolOR(prt, cur) + mSolOL(prt, cur)) * prt.dt;
}
/// <summary>
/// Масса MnO в шлаке,кг
/// mMnO(i)=mMnO(i-1)+(nOxRMn(i)+nOxLMn(i)-nRedPMnO(i))*muMnO*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mMnO(Protocol prt, Currents cur)
{
return cur.mMnO + (nOxRMn(prt, cur) + nOxLMn(prt, cur) - nRedPMnO(prt, cur)) * Constants.muMnO * prt.dt;
}
/// <summary>
/// Интенсивность вдувания газов через горелку RCB в режиме горелки кг/с
/// mGRB(i)=mO2RB(i)+mCH4RB(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <returns></returns>
public double mGRB(Protocol prt)
{
return mO2RB(prt) + mCH4RB(prt);
}
/// <summary>
/// Интенсивность вдувания газов через горелку, кг/с
/// mGB(i)=mO2B(i)+mCH4B(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <returns></returns>
public double mGB(Protocol prt)
{
return mO2B(prt) + mCH4B(prt);
}
/// <summary>
/// Масса FeO в шлаке,кг
/// mFeO(i)=mFeO(i-1)+(nOxRFe(i)+nOxLFe(i)-nRedPFeO(i))*muFeO*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mFeO(Protocol prt, Currents cur)
{
return cur.mFeO + (nOxRFe(prt, cur) + nOxLFe(prt, cur) - nRedPFeO(prt, cur)) * Constants.muFeO * prt.dt;
}
/// <summary>
/// Масса CaO в шлаке,кг
/// mCaO(i)=mCaO(i-1)
/// присадка извести: mCaO(i)=mCaO(i-1)+mLmAdd+mDlmtAdd
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mCaO(Protocol prt, Currents cur)
{
return cur.mCaO + prt.mLmAdd + prt.mDlmtAdd;
}
/// <summary>
/// Масса шлака в печи, кг
/// mSl(i)=mSl(0)+mFeO(i)+mMnO(i)+mSiO2(i)+mCaO(i)
/// Масса шлака в печи перед началом плавки,кг
/// mSl(0)=mSlH
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mSl(Protocol prt, Currents cur)
{
return prt.mSlH + cur.mFeO + cur.mMnO + cur.mSiO2 + cur.mCaO;
}
/// <summary>
/// Концентрация марганца в металле, % масс
/// CMn(i)=mMn(i)/mSt(i)*100
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CMn(Protocol prt, Currents cur)
{
return cur.mMn / cur.mSt * 100;
}
/// <summary>
/// Концентрация FeO в шлаке, % масс
/// CFeO(i)=mFeO(i)/mSl(i)*100
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CFeO(Protocol prt, Currents cur)
{
return cur.mFeO / cur.mSl * 100;
}
/// <summary>
/// Масса металла в печи,кг
/// mSt(i)=mSt(0)+mC(i)+mMn(i)+mSi(i)+mO(i)+mFe(i)
/// Масса металла в печи перед началом плавки,кг
/// mSt(0)=mStH
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mSt(Protocol prt, Currents cur)
{
return prt.mStH + cur.mC + cur.mMn + cur.mSi + cur.mO + cur.mFe;
}
/// <summary>
/// Интенсивность образования отходящих газов при работе горелки, кг/с
/// mOffGRB(i)=mOffCO2RB(i)+mOffH2ORB(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <returns></returns>
public double mOffGRB(Protocol prt)
{
return mOffCO2RB(prt) + mOffH2ORB(prt);
}
/// <summary>
/// Физическое тепло завалки, МДж
/// WCh1=mCh1*cStS*TScr(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
///<returns></returns>
public double WCh1(Protocol prt, Currents cur)
{
return prt.mCh1 * Constants.cStS * TScr(prt, cur);
}
/// <summary>
/// Интенсивность образования отходящих газов при работе горелки RCB в режиме фурмы, кг/с
/// mOffGRL(i)=mOffCORL(i)
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mOffGRL(Protocol prt, Currents cur)
{
return mOffCORL(prt, cur);
}
/// <summary>
/// Суммарный расход природного газа, м3
/// CnsCH4(i)=CnsCH4(i-1)+(UCH4B(i)+UCH4RB(i))*dt/3600
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CnsCH4(Protocol prt, Currents cur)
{
return cur.CnsCH4 + (prt.UCH4B + prt.UCH4RB) * prt.dt / 3600;
}
/// <summary>
/// Интенсивность окисления элементов металла при работе сводовой фурмы, кг/с
/// mOxL(i)=nOxLFe(i)*muFe+nOxLC(i)*muC+nOxLMn(i)*muMn+nOxLSi(i)*muSi
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mOxL(Protocol prt, Currents cur)
{
return nOxLFe(prt, cur) * Constants.muFe + nOxLC(prt, cur) * Constants.muC + nOxLMn(prt, cur) * Constants.muMn +
nOxLSi(prt, cur) * Constants.muSi;
}
private void GetMasses(Protocol prt)
{
_cur.mC = _calc.mC(prt, _cur) < 0 ? _cur.mC : _calc.mC(prt, _cur);
_cur.mFe = _calc.mFe(prt, _cur) < 0 ? _cur.mFe : _calc.mFe(prt, _cur);
_cur.mMn = _calc.mMn(prt, _cur) < 0 ? _cur.mMn : _calc.mMn(prt, _cur);
_cur.mSi = _calc.mSi(prt, _cur) < 0 ? _cur.mSi : _calc.mSi(prt, _cur);
_cur.mO = _calc.mO(prt, _cur) < 0 ? _cur.mO : _calc.mO(prt, _cur);
_cur.mCaO = _calc.mCaO(prt, _cur) < 0 ? _cur.mCaO : _calc.mCaO(prt, _cur);
_cur.mFeO = _calc.mFeO(prt, _cur) < 0 ? _cur.mFeO : _calc.mFeO(prt, _cur);
_cur.mMnO = _calc.mMnO(prt, _cur) < 0 ? _cur.mMnO : _calc.mMnO(prt, _cur);
_cur.mSiO2 = _calc.mSiO2(prt, _cur) < 0 ? _cur.mSiO2 : _calc.mSiO2(prt, _cur);
_cur.mSt = _calc.mSt(prt, _cur);
_cur.mSl = _calc.mSl(prt, _cur);
}
/// <summary>
/// Интенсивность окисления элементов металла при работе горелки RCB в режиме фурмы, кг/с
/// mOxR(i)=nOxRFe(i)*muFe+nOxRC(i)*muC+nOxRMn(i)*muMn+nOxRSi(i)*muSi
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mOxR(Protocol prt, Currents cur)
{
return nOxRFe(prt, cur) * Constants.muFe + nOxRC(prt, cur) * Constants.muC + nOxRMn(prt, cur) * Constants.muMn +
nOxRSi(prt, cur) * Constants.muSi;
}
/// <summary>
/// Интенсивность восстановления элементов из шлака при работе угольного инжектора, кг/с
/// mRedP(i)=nRedPFeO(i)*muFeO+nRedPMnO(i)*muMnO+nRedPSiO2(i)*muSiO2+nRedPC(i)*muC
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mRedP(Protocol prt, Currents cur)
{
return nRedPFeO(prt, cur) * Constants.muFeO + nRedPMnO(prt, cur) * Constants.muMnO +
nRedPSiO2(prt, cur) * Constants.muSiO2 + nRedPC(prt, cur) * Constants.muC;
}
/// <summary>
/// Масса SiO2 в шлаке,кг
/// mSiO2(i)=mSiO2(i-1)+(nOxRSi(i)+nOxLSi(i)-nRedPSiO2(i))*muSiO2*dt
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double mSiO2(Protocol prt, Currents cur)
{
return cur.mSiO2 + (nOxRSi(prt, cur) + nOxLSi(prt, cur) - nRedPSiO2(prt, cur)) * Constants.muSiO2 * prt.dt;
}
private Protocol GetProtocol()
{
var prt = new Protocol();
prt.dt = CheckValuesToInt(_dtProtocol.Rows[5][2].ToString()) - CheckValuesToInt(_dtProtocol.Rows[4][2].ToString());
prt.i = CheckValuesToInt(_dtProtocol.Rows[_rowNum][1].ToString());
prt.t = CheckValuesToInt(_dtProtocol.Rows[_rowNum][2].ToString());
prt.We = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][3].ToString());
prt.UCH4B = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][4].ToString());
prt.UO2B = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][5].ToString());
prt.UCH4RB = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][6].ToString());
prt.UO2RB = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][7].ToString());
prt.UO2RL = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][8].ToString());
prt.UO2L = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][9].ToString());
prt.mCP = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][10].ToString());
prt.mCh1 = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][11].ToString());
prt.mCh2S = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][12].ToString());
prt.mHI = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][13].ToString());
prt.mHISl = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][14].ToString());
prt.mCh1SN = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][15].ToString());
prt.THI = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][16].ToString());
prt.mCkAdd = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][17].ToString());
prt.mLmAdd = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][18].ToString());
prt.mDlmtAdd = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][19].ToString());
prt.mStTap = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][20].ToString());
prt.mSlTap = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][21].ToString());
prt.mSlTip = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][22].ToString());
prt.Tenv = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][23].ToString());
prt.TWout = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][24].ToString());
prt.TWin = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][25].ToString());
prt.UCWW = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][26].ToString());
prt.TFout = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][27].ToString());
prt.TFin = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][28].ToString());
prt.UCWF = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][29].ToString());
prt.TRout = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][30].ToString());
prt.TRin = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][31].ToString());
prt.UCWR = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][32].ToString());
prt.TSout = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][33].ToString());
prt.TSin = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][34].ToString());
prt.UCWS = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][35].ToString());
prt.TS = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][36].ToString());
prt.mAir = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][37].ToString());
prt.HIB = CheckValuesToInt(_dtProtocol.Rows[_rowNum][38].ToString());
prt.HIE = CheckValuesToInt(_dtProtocol.Rows[_rowNum][38].ToString());
if (_listHib.Count > 0 && _listHie.Count > 0)
{
if (prt.i >= _listHib[0] && prt.i <= _listHie[0])
{
prt.HIB = _listHib[0];
prt.HIE = _listHie[0];
if (prt.i == _listHie[0])
{
_listHib.Remove(0);
_listHie.Remove(0);
}
}
}
prt.Ch1 = CheckValuesToInt(_dtProtocol.Rows[_rowNum][40].ToString());
prt.Ch2S = CheckValuesToInt(_dtProtocol.Rows[_rowNum][41].ToString());
prt.Ch1SN = CheckValuesToInt(_dtProtocol.Rows[_rowNum][42].ToString());
prt.StTapB = CheckValuesToInt(_dtProtocol.Rows[_rowNum][43].ToString());
prt.StTapE = CheckValuesToInt(_dtProtocol.Rows[_rowNum][44].ToString());
if (_listStTapB.Count > 0 && _listStTapE.Count > 0)
{
if (prt.i >= _listStTapB[0] && prt.i <= _listStTapE[0])
{
prt.StTapB = _listStTapB[0];
prt.StTapE = _listStTapE[0];
if (prt.i == _listStTapE[0])
{
_listStTapB.Remove(0);
_listStTapE.Remove(0);
}
}
}
prt.SlAddB = CheckValuesToInt(_dtProtocol.Rows[_rowNum][45].ToString());
prt.SlAddE = CheckValuesToInt(_dtProtocol.Rows[_rowNum][46].ToString());
if (_listSlAddB.Count > 0 && _listSlAddE.Count > 0)
{
if (prt.i >= _listSlAddB[0] && prt.i <= _listSlAddE[0])
{
prt.SlAddB = _listSlAddB[0];
prt.SlAddE = _listSlAddE[0];
if (prt.i == _listSlAddE[0])
{
_listSlAddB.Remove(0);
_listSlAddE.Remove(0);
}
}
}
prt.mStH = CheckValuesToDouble(_dtProtocol.Rows[4][47].ToString());
prt.mSlH = CheckValuesToDouble(_dtProtocol.Rows[4][48].ToString());
prt.TH = CheckValuesToDouble(_dtProtocol.Rows[4][49].ToString());
prt.WCh1SP = CheckValuesToDouble(_dtProtocol.Rows[4][50].ToString());
prt.OCSD = CheckValuesToDouble(_dtProtocol.Rows[_rowNum][51].ToString());
return prt;
}
/// <summary>
/// Концентрация CaO в шлаке, % масс
/// CCaO(i)=mCaO(i)/mSl(i)*100
/// </summary>
/// <param name="prt">Протокол плавки</param>
/// <param name="cur">Текущие значения параметров</param>
/// <returns></returns>
public double CCaO(Protocol prt, Currents cur)
{
return cur.mCaO / cur.mSl * 100;
}
