ReceiverTank.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <functional>
#include <stdexcept>
#include <vector>
 
class ReceiverTank {
  public:
    enum class Method { General, DedicatedStorage, MeteredStorage, BridgingCompressorReactionDelay };
 
    ReceiverTank() = default;
 
    ReceiverTank(Method method, double airDemand, double allowablePressureDrop, double atmosphericPressure)
        : method(method), airDemand(airDemand), allowablePressureDrop(allowablePressureDrop),
          atmosphericPressure(atmosphericPressure) {
        if (method != ReceiverTank::Method::General) {
            throw std::runtime_error("Calculation method must be set to General to use this constructor");
        }
    }
 
    ReceiverTank(Method method, double lengthOfDemandOrDistanceToCompressorRoom, double airFlowRequirementOrSpeedOfAir,
                 double atmosphericPressure, double initialTankPressureOrAirDemand,
                 double finalTankPressureOrAllowablePressureDrop)
        : method(method), atmosphericPressure(atmosphericPressure),
          lengthOfDemandOrDistanceToCompressorRoom(lengthOfDemandOrDistanceToCompressorRoom),
          airFlowRequirementOrSpeedOfAir(airFlowRequirementOrSpeedOfAir),
          initialTankPressureOrAirDemand(initialTankPressureOrAirDemand),
          finalTankPressureOrAllowablePressureDrop(finalTankPressureOrAllowablePressureDrop) {
        if (method != ReceiverTank::Method::DedicatedStorage &&
            method != ReceiverTank::Method::BridgingCompressorReactionDelay) {
            throw std::runtime_error("Calculation method must be set to DedicatedStorage or "
                                     "BridgingCompressorReactionDelay to use this constructor");
        }
    }
 
    ReceiverTank(Method method, double lengthOfDemand, double airFlowRequirement, double atmosphericPressure,
                 double initialTankPressure, double finalTankPressure, double meteredFlowControl)
        : method(method), atmosphericPressure(atmosphericPressure),
          lengthOfDemandOrDistanceToCompressorRoom(lengthOfDemand), airFlowRequirementOrSpeedOfAir(airFlowRequirement),
          initialTankPressureOrAirDemand(initialTankPressure),
          finalTankPressureOrAllowablePressureDrop(finalTankPressure), meteredFlowControl(meteredFlowControl) {
        if (method != ReceiverTank::Method::MeteredStorage) {
            throw std::runtime_error("Calculation method must be set to MeteredStorage to use this constructor");
        }
    }
 
    double calculateUsableCapacity(const double tankSize, const double airPressureIn, const double airPressureOut) {
        return (tankSize / 7.48) * (airPressureIn - airPressureOut) / 14.7;
    }
 
    double calculateSize() {
        if (method == ReceiverTank::Method::General) {
            return airDemand * (atmosphericPressure / allowablePressureDrop) * 7.48;
        }
        else if (method == ReceiverTank::Method::DedicatedStorage) {
            return 7.48 *
                   (lengthOfDemandOrDistanceToCompressorRoom * airFlowRequirementOrSpeedOfAir * atmosphericPressure) /
                   (initialTankPressureOrAirDemand - finalTankPressureOrAllowablePressureDrop);
        }
        else if (method == ReceiverTank::Method::MeteredStorage) {
            return (7.48 * lengthOfDemandOrDistanceToCompressorRoom *
                    (airFlowRequirementOrSpeedOfAir - meteredFlowControl) * atmosphericPressure) /
                   (initialTankPressureOrAirDemand - finalTankPressureOrAllowablePressureDrop);
        }
        // method must be BridgingCompressorReactionDelay
        return (lengthOfDemandOrDistanceToCompressorRoom / airFlowRequirementOrSpeedOfAir) *
               (initialTankPressureOrAirDemand / 60) *
               (atmosphericPressure / finalTankPressureOrAllowablePressureDrop) * 7.48;
    }
 
    double calculateRefillTime() {
        double volumeGal = calculateSize();
        // * convert gal to ft3
        double volumeCf = volumeGal * 0.133681;
        double T        = (volumeCf * (initialTankPressureOrAirDemand - finalTankPressureOrAllowablePressureDrop)) /
                   (meteredFlowControl * atmosphericPressure);
        return T * 60;
    }
 
  private:
    Method method;
    double airDemand, allowablePressureDrop, atmosphericPressure;
 
    double lengthOfDemandOrDistanceToCompressorRoom, airFlowRequirementOrSpeedOfAir, initialTankPressureOrAirDemand;
    double finalTankPressureOrAllowablePressureDrop;
 
    double meteredFlowControl;
};