CompressedAir.h

#ifndef AMO_TOOLS_SUITE_COMPRESSEDAIR_H
#define AMO_TOOLS_SUITE_COMPRESSEDAIR_H

#include <vector>
#include <cmath>
#include <stdexcept>
#include <functional>

class CompressedAir{
public:
    enum CompressorType {
        Centrifugal
    };
};

class PneumaticAirRequirement {
public:
    enum class PistonType {
        SingleActing,
        DoubleActing
    };

    PneumaticAirRequirement(PistonType pistonType, double cylinderDiameter, double cylinderStroke, double pistonRodDiameter,
                            double airPressure, double cyclesPerMin);

    PneumaticAirRequirement(PistonType pistonType, double cylinderDiameter, double cylinderStroke, double airPressure,
                            double cyclesPerMin);

    PneumaticAirRequirement() = default;

    class Output {
    public:
        Output(const double volumeAirIntakePiston, const double compressionRatio,
               const double airRequirementPneumaticCylinder)
                : volumeAirIntakePiston(volumeAirIntakePiston),
                  compressionRatio(compressionRatio),
                  airRequirementPneumaticCylinder(airRequirementPneumaticCylinder)
        {}

        const double volumeAirIntakePiston, compressionRatio, airRequirementPneumaticCylinder;
    };

    Output calculate();

private:
    PistonType pistonType;
    double cylinderDiameter, cylinderStroke, pistonRodDiameter = 0, airPressure, cyclesPerMin;
};

class ReceiverTank {
public:
    enum class Method {
        General,
        DedicatedStorage,
        MeteredStorage,
        BridgingCompressorReactionDelay
    };

    ReceiverTank() = default;

    ReceiverTank(Method method, double airDemand, double allowablePressureDrop, double atmosphericPressure);

    ReceiverTank(Method method, double lengthOfDemandOrDistanceToCompressorRoom, double airFlowRequirementOrSpeedOfAir,
                 double atmosphericPressure, double initialTankPressureOrAirDemand, double finalTankPressureOrAllowablePressureDrop);

    ReceiverTank(Method method, double lengthOfDemand, double airFlowRequirement, double atmosphericPressure,
                 double initialTankPressure, double finalTankPressure, double meteredFlowControl);

    static double calculateUsableCapacity(const double tankSize, const double airPressureIn, const double airPressureOut) {
        return (tankSize / 7.48) * (airPressureIn - airPressureOut) / 14.7;
    }

    double calculateSize();

private:
    Method method;
    double airDemand, allowablePressureDrop, atmosphericPressure;

    double lengthOfDemandOrDistanceToCompressorRoom, airFlowRequirementOrSpeedOfAir, initialTankPressureOrAirDemand;
    double finalTankPressureOrAllowablePressureDrop;

    double meteredFlowControl;
};

namespace Compressor {
    struct PipeData {
        PipeData(const double oneHalf, const double threeFourths, const double one, const double oneAndOneFourth,
                 const double oneAndOneHalf, const double two, const double twoAndOneHalf, const double three,
                 const double threeAndOneHalf, const double four, const double five, const double six, const double eight, 
                 const double ten, const double twelve, const double fourteen, const double sixteen, const double eighteen, 
                 const double twenty, const double twentyFour)
                : oneHalf(oneHalf * 0.0021), threeFourths(threeFourths * 0.0037), one(one * 0.006),
                  oneAndOneFourth(oneAndOneFourth * 0.0104), oneAndOneHalf(oneAndOneHalf * 0.0141),
                  two(two * 0.0233), twoAndOneHalf(twoAndOneHalf * 0.0333), three(three * 0.0513),
                  threeAndOneHalf(threeAndOneHalf * 0.0687), four(four * 0.0884), five(five * 0.1389),
                  six(six * 0.2006), eight(eight * 0.3442), ten(ten * 0.5476), twelve(twelve * 0.7763), fourteen(fourteen * 0.9354), // **ten and twelve**
                  sixteen(sixteen * 1.223), eighteen(eighteen * 1.555), twenty(twenty * 1.926), twentyFour(twentyFour * 2.793),
                  totalPipeVolume(this->oneHalf + this->threeFourths + this->one + this->oneAndOneFourth
                                  + this->oneAndOneHalf + this->two + this->twoAndOneHalf + this->three
                                  + this->threeAndOneHalf + this->four + this->five + this->six
                                  + this->eight + this->ten + this->twelve + this->fourteen + this->sixteen
                                  + this->eighteen + this->twenty + this->twentyFour)
        {}

        explicit PipeData(std::function<double (const double)> const & compVel)
                : oneHalf(compVel(0.3)), threeFourths(compVel(0.53)), one(compVel(0.86)),
                  oneAndOneFourth(compVel(1.5)), oneAndOneHalf(compVel(2.04)),
                  two(compVel(3.36)), twoAndOneHalf(compVel(4.79)), three(compVel(7.39)),
                  threeAndOneHalf(compVel(9.89)), four(compVel(12.73)), five(compVel(20)),
                  six(compVel(28.89)), eight(compVel(50.02)), ten(compVel(78.85)), twelve(compVel(111.9)),
                  fourteen(compVel(135.3)), sixteen(compVel(176.7)), eighteen(compVel(224)), twenty(compVel(278)),
                  twentyFour(compVel(402.10))
        {}

        const double oneHalf, threeFourths, one, oneAndOneFourth, oneAndOneHalf, two;
        const double twoAndOneHalf, three, threeAndOneHalf, four, five, six;
        const double eight, ten, twelve, fourteen, sixteen, eighteen, twenty, twentyFour;
        const double totalPipeVolume = 0;
    };

    class OperatingCost {
    public:
        OperatingCost(double motorBhp, double bhpUnloaded, double annualOperatingHours, double runTimeLoaded,
                      double efficiencyLoaded, double efficiencyUnloaded, double costOfElectricity);

        struct Output {
            Output(const double runTimeUnloaded, const double costForLoaded, const double costForUnloaded,
                   const double totalAnnualCost)
                    : runTimeUnloaded(runTimeUnloaded), costForLoaded(costForLoaded),
                      costForUnloaded(costForUnloaded), totalAnnualCost(totalAnnualCost)
            {}

            const double runTimeUnloaded, costForLoaded, costForUnloaded, totalAnnualCost;
        };

        Output calculate();

    private:
        double motorBhp, bhpUnloaded, annualOperatingHours, runTimeLoaded, efficiencyLoaded;
        double efficiencyUnloaded, costOfElectricity;
    };


    class AirSystemCapacity {
    public:
        struct Output {
            Output(const double totalPipeVolume, std::vector<double> receiverCapacities,
                   const double totalReceiverVol, const double totalCapacityOfCompressedAirSystem,
                   PipeData pipeLengths)
                    : totalPipeVolume(totalPipeVolume), totalReceiverVol(totalReceiverVol),
                      totalCapacityOfCompressedAirSystem(totalCapacityOfCompressedAirSystem),
                      receiverCapacities(std::move(receiverCapacities)), pipeLengths(pipeLengths)
            {}

            const double totalPipeVolume, totalReceiverVol, totalCapacityOfCompressedAirSystem;
            const std::vector<double> receiverCapacities;
            const PipeData pipeLengths;
        };

        AirSystemCapacity(PipeData pipeLengths, std::vector<double> gallons);

        Output calculate();

    private:
        PipeData pipeLengths;
        std::vector<double> receivers;
    };

    class AirVelocity {
    public:
        AirVelocity(double airFlow, double pipePressure, double atmosphericPressure);

        Compressor::PipeData calculate();

    private:
        double airFlow, pipePressure, atmosphericPressure;
    };

    class PipeSizing {
    public:
        struct Output {
            Output(const double crossSectionalArea, const double pipeDiameter)
                    : crossSectionalArea(crossSectionalArea), pipeDiameter(pipeDiameter)
            {}
            const double crossSectionalArea, pipeDiameter;
        };

        PipeSizing(double airflow, double airlinePressure, double designVelocity, double atmosphericPressure);

        Output calculate();

    private:
        double airflow, airlinePressure, designVelocity, atmosphericPressure;
    };

    class PneumaticValve {
    public:
        PneumaticValve(double inletPressure, double outletPressure);
        PneumaticValve(double inletPressure, double outletPressure, double flowRate);

        double calculate();

    private:
        double inletPressure, outletPressure, flowRate;
        bool flowRateKnown;
    };
}

class BagMethod {
public:
    struct Output {
        Output(const double flowRate, const double annualConsumption)
                : flowRate(flowRate), annualConsumption(annualConsumption)
        {}

        const double flowRate, annualConsumption;
    };

    BagMethod(double operatingTime, double bagFillTime, double heightOfBag, double diameterOfBag, int numberOfUnits);

    Output calculate();

private:
    double operatingTime, bagFillTime, heightOfBag, diameterOfBag, numberOfUnits;
};

// enum class CompressorType ???

class EstimateMethod {
    public:
        struct Output {
            Output(const double annualConsumption) : annualConsumption(annualConsumption)
            {}

            const double annualConsumption;
        };

        EstimateMethod(const double operatingTime, const double leakRateEstimate);

        Output calculate();

    private:
        double operatingTime, leakRateEstimate;
};

class DecibelsMethod {
  public:
    struct Output {
        Output(const double leakRateEstimate, const double annualConsumption) 
            : leakRateEstimate(leakRateEstimate), annualConsumption(annualConsumption)
        {}

        const double leakRateEstimate, annualConsumption;
    };

    DecibelsMethod(const double operatingTime, const double linePressure, const double decibels, const double decibelRatingA, 
        const double pressureA, const double firstFlowA, const double secondFlowA, const double decibelRatingB, const double pressureB,
        const double firstFlowB, const double secondFlowB);

    Output calculate();

  private:
    double operatingTime;
    double linePressure; // X
    double decibels; // Y
    double decibelRatingA; // Y1
    double pressureA; // X1
    double firstFlowA; // Q11
    double secondFlowA; // Q21
    double decibelRatingB; // Y2
    double pressureB; // X2
    double firstFlowB; // Q12
    double secondFlowB; // Q22
};

class OrificeMethod {
    public:
        struct Output {
            Output(const double standardDensity, const double sonicDensity, const double leakVelocity, const double leakRateLBMmin,
                const double leakRateScfm, const double leakRateEstimate, const double annualConsumption) 
                : standardDensity(standardDensity), sonicDensity(sonicDensity), leakVelocity(leakVelocity),
                  leakRateLBMmin(leakRateLBMmin), leakRateScfm(leakRateScfm), leakRateEstimate(leakRateEstimate),
                  annualConsumption(annualConsumption)
            {}

            const double standardDensity, sonicDensity, leakVelocity, leakRateLBMmin, leakRateScfm, leakRateEstimate, annualConsumption;
        };

        OrificeMethod(const double operatingTime, const double airTemp, const double atmPressure, const double dischargeCoef,
            const double diameter, const double supplyPressure, const int numOrifices);

        Output calculate();

    private:
        double operatingTime, airTemp, atmPressure, dischargeCoef, diameter, supplyPressure;
        int numOrifices;

};

class AirLeakSurvey {
    enum class MethodType
    {
        EstimateMethod,
        DecibelsMethod,
        BagMethod,
        OrificeMethod
    };
    /*
    annualOperatingHours: number;
    // 
    // leakDescription 
    // anualOperatingHours 
    // measurementMethod 
    // utilityType = 'electricity' or 'compressed air'
    // utilityCost comes from TH setup but is editable input
    // compressorControlType
    // compressorType 
    leaks: Array<AirLeakSurveyData>;
    */
};

#endif //AMO_TOOLS_SUITE_COMPRESSEDAIR_H