public override FlowResponseData getFlowDriverDeliveryPossibleValues(FlowCalculationData baseData, FlowDriverModifier modifier)
{
pumpingPercent = lastSourcePossibleValue.flowPercent;
mcrPressure = lastSourcePossibleValue.backPressure;
FlowResponseData normalResponse = base.getFlowDriverDeliveryPossibleValues(baseData, modifier);
double deltaP = lastSourcePossibleValue.backPressure - normalResponse.backPressure;
if (deltaP < minDeltaP)
{
normalResponse.flowPercent = 0.0;
}
else
{
double flowPercent = 1.0; //Default to 1, in case deltaP > maxDeltaP, in which case, we do 100% of what we can.
if (deltaP < maxDeltaP)
{
flowPercent = (deltaP - minDeltaP) / (maxDeltaP - minDeltaP);
}
normalResponse.flowPercent = Math.Min(normalResponse.flowPercent, lastSourcePossibleValue.flowPercent) * flowPercent;
}
normalResponse.flowVolume = baseData.desiredFlowVolume * normalResponse.flowPercent;
return normalResponse;
}
public override FlowResponseData getFlowDriverSourcePossibleValues(FlowCalculationData baseData, FlowDriverModifier modifier)
{
pumpingPercent = 1.0;
FlowResponseData normalResponse = base.getFlowDriverSourcePossibleValues(baseData, modifier);
lastSourcePossibleValue = normalResponse;
return normalResponse;
}
public bool applySolution(FlowCalculationData baseData, FlowDriverModifier modifier, bool lastTime)
{
if (solutionApplied)
return true; //If we have already successfully sent all our data, then we shouldn't do it again...
SettingResponseData sourceResponse = setSourceValues(baseData, null, pumpingPercent * mcrRating * modifier.flowPercent, lastTime);
if (sourceResponse != null)
{
baseData.applySourceResponse(sourceResponse);
setDeliveryValues(baseData, null, pumpingPercent * mcrRating * modifier.flowPercent, lastTime);
solutionApplied = true;
}
return solutionApplied;
}
public virtual FlowResponseData getFlowDriverSourcePossibleValues(FlowCalculationData baseData, FlowDriverModifier modifier)
{
//This shouldn't happen anymore, since GraphSolver calls the pump-specific (i.e. not override) version.
baseData.flowDriver = this;
baseData.desiredFlowVolume = pumpingPercent * mcrRating * modifier.flowPercent;
baseData.pressure = calculateInletPressure(modifier);
inletPressure = baseData.pressure;
//We only do last response on the source side for pumps (all other components only have one side for this stuff...
return sourceComponent.getSourcePossibleValues(baseData, this, 1.0, 1.0); //Always ask 100% of whatever desired flow we have. Will send smaller percent upon solving whole solution.
}
public virtual FlowResponseData getFlowDriverDeliveryPossibleValues(FlowCalculationData baseData, FlowDriverModifier modifier)
{
baseData.flowDriver = this;
baseData.desiredFlowVolume = pumpingPercent * mcrRating * modifier.flowPercent;
baseData.pressure = calculateOutletPressure(modifier);
outletPressure = baseData.pressure;
return deliveryComponent.getDeliveryPossibleValues(baseData, this, 1.0, 1.0); //Always ask 100% of whatever desired flow we have
}
protected double calculateOutletPressure(FlowDriverModifier modifier)
{
double ret = mcrPressure * pumpingPercent * modifier.minSourceFlowPercent; //The source is the main thing that can drop the pressure
if (modifier.minSourceFlowPercent > modifier.minDeliveryFlowPercent && modifier.minSourceFlowPercent > 0.0)
{
//This is functionality more typical of a centrifugal pump.
//If the delivery side is more clogged than the source, then we can add back some because of back pressure.
ret *= (1.0 + 0.20 * (1.0 - modifier.minDeliveryFlowPercent / modifier.minSourceFlowPercent)); //Allow up to 20% higher pressure if the output is clogged
}
return ret;
}
protected double calculateInletPressure(FlowDriverModifier modifier)
{
double ret = -0.2 * pumpingPercent; //By default, it will be about -0.2 bar when running at 100% normally
ret *= (1 + (2.0 * (1.0 - modifier.minSourceFlowPercent))); //If the source is blocked, it can increase by up to 3x
return ret;
}
