320 lines
12 KiB
C#
320 lines
12 KiB
C#
using log4net;
|
|
using SchematicDrawing;
|
|
using SharedComponents;
|
|
///
|
|
/// Copyright (c) 2021-2022 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using TBF.Boxes;
|
|
using TBF.Rig.ControlBoard.Uni;
|
|
using TBF.Rig.GenericDevices;
|
|
|
|
namespace TBF.Rig.Uni.FlowMetersInParallel
|
|
{
|
|
public class FlowMeter : ComponentBase, IFlowMeter, IDrawingItCmpntWithMeasuredVal
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(FlowMeter));
|
|
public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); }
|
|
|
|
readonly FlowMeterCfg flowMeterCfg;
|
|
|
|
UniCB uniCB;
|
|
IFlowMeterSingle flowMtr1;
|
|
IFlowMeterSingle flowMtr2;
|
|
IFlowMeterSingle flowMtr3;
|
|
double nominalFlow;
|
|
double nominalFreq;
|
|
double ltrPerPulse;
|
|
int flowMetersCount;
|
|
int flowMetersBitfield;
|
|
|
|
public int Idx1 { get { return flowMetersBitfield; } }
|
|
public double NominalFlow { get { return nominalFlow; } }
|
|
public double NominalFreq { get { return nominalFreq; } }
|
|
public double LtrPerPulse { get { return ltrPerPulse; } }
|
|
|
|
public SchematicDrawing.IDrawingItem DrawingItem { get { return flowMeterCfg as SchematicDrawing.IDrawingItem; } }
|
|
public string MsrdFormat { get { return flowMeterCfg.MsrdFormat; } }
|
|
public Common.Unit MsrdUnit { get { return flowMeterCfg.MsrdUnit; } }
|
|
public double MsrdValLimLo { get { return flowMeterCfg.MsrdValLimLo; } set { flowMeterCfg.MsrdValLimLo = value; } }
|
|
public double MsrdValLimHi { get { return flowMeterCfg.MsrdValLimHi; } set { flowMeterCfg.MsrdValLimHi = value; } }
|
|
|
|
public bool MsrmntAvailable
|
|
{
|
|
get
|
|
{
|
|
bool result = true;
|
|
if (flowMtr1 != null) result = result && flowMtr1.MsrmntAvailable;
|
|
if (flowMtr2 != null) result = result && flowMtr2.MsrmntAvailable;
|
|
if (flowMtr3 != null) result = result && flowMtr3.MsrmntAvailable;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public double MeasuredVal
|
|
{
|
|
get { return ReadFlow(); }
|
|
}
|
|
|
|
public string AltString { get { return "Invalid format"; } }
|
|
|
|
public FlowMeter() { }
|
|
|
|
public FlowMeter(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
|
|
: base(cfg)
|
|
{
|
|
flowMeterCfg = cfg as FlowMeterCfg;
|
|
}
|
|
|
|
public override void Initialize()
|
|
{
|
|
uniCB = TbfComponents.FindComponent(flowMeterCfg.ParentName) as UniCB;
|
|
if (uniCB == null) throw new Exception("Cannot find " + Name + " parent");
|
|
|
|
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter1)) flowMtr1 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter1) as IFlowMeterSingle;
|
|
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter2)) flowMtr2 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter2) as IFlowMeterSingle;
|
|
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter3)) flowMtr3 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter3) as IFlowMeterSingle;
|
|
|
|
LiveLogDiag.Log1("{0} >> Initialize() >> ----------------------initialising------------------------", Name);
|
|
|
|
nominalFlow = 0;
|
|
nominalFreq = 0;
|
|
flowMetersCount = 0;
|
|
flowMetersBitfield = 0;
|
|
|
|
if (flowMtr1 != null)
|
|
{
|
|
nominalFlow += flowMtr1.NominalFlow;
|
|
nominalFreq += flowMtr1.NominalFreq;
|
|
flowMetersBitfield |= (4 << flowMtr1.Idx1);
|
|
flowMetersCount++;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> Initialize() >> flowMtr1.NominalFlow = {1} m3/h flowMtr1.NominalFreq = {2} Hz",
|
|
Name, flowMtr1.NominalFlow, flowMtr1.NominalFreq);
|
|
}
|
|
|
|
if (flowMtr2 != null)
|
|
{
|
|
nominalFlow += flowMtr2.NominalFlow;
|
|
nominalFreq += flowMtr2.NominalFreq;
|
|
flowMetersBitfield |= (4 << flowMtr2.Idx1);
|
|
flowMetersCount++;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> Initialize() >> flowMtr2.NominalFlow = {1} m3/h flowMtr2.NominalFreq = {2} Hz",
|
|
Name, flowMtr2.NominalFlow, flowMtr2.NominalFreq);
|
|
}
|
|
|
|
if (flowMtr3 != null)
|
|
{
|
|
nominalFlow += flowMtr3.NominalFlow;
|
|
nominalFreq += flowMtr3.NominalFreq;
|
|
flowMetersBitfield |= (4 << flowMtr3.Idx1);
|
|
flowMetersCount++;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> Initialize() >> flowMtr3.NominalFlow = {1} m3/h flowMtr3.NominalFreq = {2} Hz",
|
|
Name, flowMtr3.NominalFlow, flowMtr3.NominalFreq);
|
|
}
|
|
|
|
if (flowMetersCount == 0) throw new Exception("Missing flowmeters");
|
|
|
|
MsrdValLimHi = nominalFlow;
|
|
|
|
ltrPerPulse = nominalFlow / (3.6 * nominalFreq);
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> Initialize() >> nominalFlow = {1} m3/h nominalFreq = {2} Hz bitfield = 0x{3:X2} ltrPerPulse = {4}",
|
|
Name, nominalFlow, nominalFreq, flowMetersBitfield, ltrPerPulse);
|
|
|
|
log.FatalFormat(
|
|
"{0} initialized: nom.flow={1} m3/h nom.freq={2} Hz bitfield=0x{3:X2}",
|
|
Name, nominalFlow, nominalFreq, flowMetersBitfield);
|
|
}
|
|
|
|
public double ReadFlow()
|
|
{
|
|
double flowByNewFormulaSum = 0;
|
|
|
|
if (flowMtr1 != null)
|
|
{
|
|
double contrib1 = flowMtr1.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr1.Idx1] / flowMtr1.NominalFreq;
|
|
flowByNewFormulaSum += contrib1;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> ReadFlow() >> FM1: NominalFlow={1} m3/h RefFreq[1]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
|
Name, flowMtr1.NominalFlow, uniCB.Data.ReferenceFreq[1], flowMtr1.NominalFreq, contrib1);
|
|
}
|
|
|
|
if (flowMtr2 != null)
|
|
{
|
|
double contrib2 = flowMtr2.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr2.Idx1] / flowMtr2.NominalFreq;
|
|
flowByNewFormulaSum += contrib2;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> ReadFlow() >> FM2: NominalFlow={1} m3/h RefFreq[2]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
|
Name, flowMtr2.NominalFlow, uniCB.Data.ReferenceFreq[2], flowMtr2.NominalFreq, contrib2);
|
|
}
|
|
|
|
if (flowMtr3 != null)
|
|
{
|
|
double contrib3 = flowMtr3.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr3.Idx1] / flowMtr3.NominalFreq;
|
|
flowByNewFormulaSum += contrib3;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> ReadFlow() >> FM3: NominalFlow={1} m3/h RefFreq[3]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
|
Name, flowMtr3.NominalFlow, uniCB.Data.ReferenceFreq[3], flowMtr3.NominalFreq, contrib3);
|
|
}
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> ReadFlow() >> return = flowByNewFormulaSum = {1} m3/h",
|
|
Name, flowByNewFormulaSum);
|
|
LiveLogDiag.Log1(
|
|
"{0} >> FM1: Idx1={1}, RefFreq[1]={2}, RefFreq[Idx1]={3}",
|
|
Name,
|
|
flowMtr1.Idx1,
|
|
uniCB.Data.ReferenceFreq[1],
|
|
uniCB.Data.ReferenceFreq[flowMtr1.Idx1]);
|
|
|
|
return flowByNewFormulaSum;
|
|
}
|
|
|
|
public double ReadFrequency()
|
|
{
|
|
double freq = uniCB.RefFrequency;
|
|
LiveLogDiag.Log1("{0} >> ReadFrequency() >> return = {1} Hz", Name, freq);
|
|
return freq;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: FlowDone, Error
|
|
/// </summary>
|
|
public IOperation ReadFlowOp(ref DoubleBox flow)
|
|
{
|
|
LiveLogDiag.Log1("{0} >> ReadFlowOp(ref DoubleBox) >> operation created", Name);
|
|
return new ReadFlowOp(this, ref flow);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: flowDone, Error
|
|
/// </summary>
|
|
public IOperation ReadFlowOp(ref DoubleBox flow, Event flowDone)
|
|
{
|
|
LiveLogDiag.Log1("{0} >> ReadFlowOp(ref DoubleBox, Event) >> operation created", Name);
|
|
return new ReadFlowOp(this, ref flow, flowDone);
|
|
}
|
|
|
|
double flowRawSum;
|
|
double flowSum;
|
|
int timeSum;
|
|
int rng1;
|
|
int rng2;
|
|
int rng3;
|
|
|
|
public void StartStatistics(Config.Entities.Test test)
|
|
{
|
|
flowRawSum = 0;
|
|
flowSum = 0;
|
|
timeSum = 0;
|
|
|
|
if (flowMtr1 != null) rng1 = Math.Max(0, flowMtr1.GetRange(test.TempLimLo, test.TempLimHi));
|
|
if (flowMtr2 != null) rng2 = Math.Max(0, flowMtr2.GetRange(test.TempLimLo, test.TempLimHi));
|
|
if (flowMtr3 != null) rng3 = Math.Max(0, flowMtr3.GetRange(test.TempLimLo, test.TempLimHi));
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> StartStatistics() >> flowRawSum={1} flowSum={2} timeSum={3} rng1={4} rng2={5} rng3={6}",
|
|
Name, flowRawSum, flowSum, timeSum, rng1, rng2, rng3);
|
|
}
|
|
|
|
public void UpdateStatistics(int timeDelta)
|
|
{
|
|
double tempFlow;
|
|
|
|
if (flowMtr1 != null)
|
|
{
|
|
tempFlow = flowMtr1.ReadFlow();
|
|
flowRawSum += timeDelta * tempFlow;
|
|
flowSum += timeDelta * flowMtr1.CorrectedFlow(tempFlow, rng1);
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> UpdateStatistics() >> FM1: timeDelta={1} tempFlow={2} corrected={3}",
|
|
Name, timeDelta, tempFlow, flowMtr1.CorrectedFlow(tempFlow, rng1));
|
|
}
|
|
|
|
if (flowMtr2 != null)
|
|
{
|
|
tempFlow = flowMtr2.ReadFlow();
|
|
flowRawSum += timeDelta * tempFlow;
|
|
flowSum += timeDelta * flowMtr2.CorrectedFlow(tempFlow, rng2);
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> UpdateStatistics() >> FM2: timeDelta={1} tempFlow={2} corrected={3}",
|
|
Name, timeDelta, tempFlow, flowMtr2.CorrectedFlow(tempFlow, rng2));
|
|
}
|
|
|
|
if (flowMtr3 != null)
|
|
{
|
|
tempFlow = flowMtr3.ReadFlow();
|
|
flowRawSum += timeDelta * tempFlow;
|
|
flowSum += timeDelta * flowMtr3.CorrectedFlow(tempFlow, rng3);
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> UpdateStatistics() >> FM3: timeDelta={1} tempFlow={2} corrected={3}",
|
|
Name, timeDelta, tempFlow, flowMtr3.CorrectedFlow(tempFlow, rng3));
|
|
}
|
|
|
|
timeSum += timeDelta;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> UpdateStatistics() >> flowRawSum={1} flowSum={2} timeSum={3}",
|
|
Name, flowRawSum, flowSum, timeSum);
|
|
}
|
|
|
|
public void StopStatistics()
|
|
{
|
|
flowRawSum /= Convert.ToDouble(timeSum);
|
|
flowSum /= Convert.ToDouble(timeSum);
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> StopStatistics() >> flowRawSum={1:F3} m3/h flowSum={2:F3} m3/h",
|
|
Name, flowRawSum, flowSum);
|
|
|
|
log.WarnFormat(
|
|
"StopStatistics() flowRawSum = {0:F3} m3/h flowSum = {1:F3} m3/h",
|
|
flowRawSum, flowSum);
|
|
}
|
|
|
|
public double LtrPerPulseCorrected(double flow, float temperature)
|
|
{
|
|
double ltrPerPulseCorrected = (flowRawSum == 0)
|
|
? LtrPerPulse
|
|
: LtrPerPulse * flowSum / flowRawSum;
|
|
|
|
LiveLogDiag.Log1(
|
|
"{0} >> LtrPerPulseCorrected() >> flow={1} m3/h flowRawSum={2} flowSum={3} temperature={4} C ltrPerPulseCorrected={5}",
|
|
Name, flow, flowRawSum, flowSum, temperature, ltrPerPulseCorrected);
|
|
|
|
log.WarnFormat(
|
|
"LtrPerPulseCorrected() flow = {0} m3/h flowRawSum = {1} m3/h flowSum = {2} m3/h temperature = {3} C ltrPerPulseCorrected = {4}",
|
|
flow, flowRawSum, flowSum, temperature, ltrPerPulseCorrected);
|
|
|
|
return ltrPerPulseCorrected;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logging
|
|
/// For activation use compilation condition: LIVELOGDIAG_FlowMeter_cs
|
|
/// </summary>
|
|
static class LiveLogDiag
|
|
{
|
|
[Conditional("LIVELOGDIAG_FlowMeter_cs")]
|
|
public static void Log1(string format, params object[] args)
|
|
{
|
|
LiveLogCache.Instance.AddLog("FlowMeter.cs LOG>> " + string.Format(format, args));
|
|
}
|
|
}
|
|
}
|
|
} |