fan_affinity_laws.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <cmath>
 
class FanAffinityLaws {
public:
    enum MotorControlType {
        OnOff,
        TwoSpeed,
        VSD,
        None
    };
 
    enum FlowMode {
        Percent,
        Volume
    };
 
    struct Output {
        Output(const double annualEnergyBaseline, const double annualEnergyNew, const double annualCostSavings)
            : annualEnergyBaseline(annualEnergyBaseline), annualEnergyNew(annualEnergyNew), annualCostSavings(annualCostSavings) {}
 
        const double annualEnergyBaseline, annualEnergyNew, annualCostSavings;
    };
 
    struct Input {
        double electricityCost;
        double driveEfficiency, motorEfficiency, flowPercentBaseline;
        double operatingHours, motorPower, ratedFlow;
        MotorControlType motorControlTypeCurrent, motorControlTypeNew;
        FlowMode flowMode;
        double desiredFlowRate;
    };
 
    FanAffinityLaws(const Input& input) : FanAffinityLaws(input.electricityCost, input.driveEfficiency, input.motorEfficiency, input.flowPercentBaseline,
        input.operatingHours, input.motorPower, input.ratedFlow,
        input.motorControlTypeCurrent, input.motorControlTypeNew,
        input.flowMode, input.desiredFlowRate) {}
 
    FanAffinityLaws(const double electricityCost,
        const double driveEfficiency, const double motorEfficiency, const double flowPercentBaseline,
        const double operatingHours, const double motorPower, const double ratedFlow,
        const MotorControlType motorControlTypeCurrent, const MotorControlType motorControlTypeNew,
        const FlowMode flowMode, const double desiredFlowRate) : electricityCost(electricityCost),
            driveEfficiency(driveEfficiency/100), motorEfficiency(motorEfficiency/100), flowPercentBaseline(flowPercentBaseline/100),
            operatingHours(operatingHours), motorPower(motorPower), ratedFlow(ratedFlow),
            motorControlTypeCurrent(motorControlTypeCurrent), motorControlTypeNew(motorControlTypeNew) {
        if (electricityCost <= 0) {
            throw std::invalid_argument("Electricity cost must be greater than 0.");
        }
        if (driveEfficiency <= 0 || driveEfficiency > 100) {
            throw std::invalid_argument("Drive efficiency must be between 0 and 100.");
        }
        if (motorEfficiency <= 0 || motorEfficiency > 100) {
            throw std::invalid_argument("Motor efficiency must be between 0 and 100.");
        }
        if (flowPercentBaseline < 0 || flowPercentBaseline > 100) {
            throw std::invalid_argument("Flow percent baseline must be between 0 and 100.");
        }
        if (operatingHours <= 0 || operatingHours > 8760) {
            throw std::invalid_argument("Operating hours must be between 1 and 8760.");
        }
        if (motorPower <= 0) {
            throw std::invalid_argument("Motor power must be greater than 0.");
        }
        if (ratedFlow <= 0) {
            throw std::invalid_argument("Rated flow must be greater than 0.");
        }
 
        if (flowMode == Percent) {
            if (desiredFlowRate < 0 || desiredFlowRate > 100) {
                throw std::invalid_argument("Desired flow rate percentage must be between 0 and 100.");
            }
            desiredFlowPercent = desiredFlowRate / 100.0;
            desiredFlowVolume = desiredFlowRate * ratedFlow / 100.0;
        } else if (flowMode == Volume) {
            if (desiredFlowRate < 0) {
                throw std::invalid_argument("Desired flow rate volume must be greater than or equal to 0.");
            }
            desiredFlowVolume = desiredFlowRate;
            desiredFlowPercent = desiredFlowRate / ratedFlow;
        }
    }
 
    Output calculate() const { return compute(0.0); }
 
    Output changeFanSize(const double fanDiameterCurrent, const double fanDiameter) const {
        if (fanDiameterCurrent <= 0 || fanDiameter <= 0) {
            throw std::invalid_argument("Fan diameters must be greater than 0.");
        }
 
        return compute(fanDiameter / fanDiameterCurrent);
    }
 
private:
    const double electricityCost;
    const double driveEfficiency, motorEfficiency, flowPercentBaseline;
    const double operatingHours, motorPower, ratedFlow;
    const MotorControlType motorControlTypeCurrent, motorControlTypeNew;
    double desiredFlowPercent = 0, desiredFlowVolume = 0;
 
    Output compute(const double fanDiameterRatio) const {
        const double powerBaseline = motorPower / motorEfficiency / driveEfficiency;
 
        double powerCurrent = powerBaseline;
        if (motorControlTypeCurrent == VSD) {
            powerCurrent *= std::pow(flowPercentBaseline, 3);
        }
        else if (motorControlTypeCurrent == TwoSpeed) {
            powerCurrent = powerBaseline * get50PercentTimeFactor(flowPercentBaseline);
        }
 
        double powerNew = powerBaseline;
        if (motorControlTypeNew == TwoSpeed) {
            powerNew = powerBaseline * get50PercentTimeFactor(desiredFlowPercent);
        }
 
        if (fanDiameterRatio != 0) {
            if (motorControlTypeNew == VSD) {
                const auto fanRatedFlow   = ratedFlow * std::pow(fanDiameterRatio, 3);
                const auto newFlowPercent = desiredFlowVolume / fanRatedFlow;
                powerNew                  = powerBaseline * std::pow(newFlowPercent, 3) * std::pow(fanDiameterRatio, 5);
            }
            else if (motorControlTypeNew == TwoSpeed) {
                powerNew *= std::pow(fanDiameterRatio, 5);
            }
            else {
                powerNew = powerBaseline * std::pow(fanDiameterRatio, 5);
            }
        }
        else if (motorControlTypeNew == VSD) {
            powerNew = powerBaseline * std::pow(desiredFlowPercent, 3);
        }
 
        return {powerCurrent * operatingHours, powerNew * operatingHours,
            (powerCurrent - powerNew) * operatingHours * electricityCost};
    }
 
    static double get50PercentTimeFactor(const double flowPercent) {
        const double timeAbove50Percent = (flowPercent - 0.5) / 0.5 < 0 ? 0 : (flowPercent - 0.5) / 0.5;
        const double timeAt0Percent     = (0.5 - flowPercent) / 0.5 < 0 ? 0 : (0.5 - flowPercent) / 0.5;
        const double timeAt50Percent    = 1 - timeAbove50Percent - timeAt0Percent;
 
        return timeAbove50Percent + timeAt50Percent * 0.125;
    }
};