#include "nmDataForecast.h"

PressureRow::PressureRow() {
    const QStringList timeUnits = (QStringList()
        << "ms" << "sec" << "min" << "hr" << "day"
        << "Week" << "week" << "Month" << "month" << "Year" << "year");
    const QStringList pressureUnits = (QStringList()
        << "MPa" << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2"
        << "psig" << "bar" << "kPag");

    duration = nmDataAttribute("Duration", 8760.0, "hr", UNIT_TYPE_TIME, QStringList(), timeUnits);
    pressure = nmDataAttribute("Pressure", 23.046, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
};

FlowRow::FlowRow() {
    const QStringList timeUnits = (QStringList()
        << "ms" << "sec" << "min" << "hr" << "day"
        << "Week" << "week" << "Month" << "month" << "Year" << "year");
    const QStringList flowRateUnits = (QStringList()
        << "B/D" << "MMm^3/D" << "Mcf/D" << "Mm^3/D" << "Mm^3/hr" << "U.K. gal/hr" << "U.K. gal/min"
        << "U.S. gal/hr" << "U.S. gal/min" << "cf/D" << "cf/s"
        << "cm^3/sec" << "l/min" << "m^3/D" << "m^3/hr" << "m^3/min" << "m^3/sec");

    duration = nmDataAttribute("Duration", 8760.0, "hr", UNIT_TYPE_TIME, QStringList(), timeUnits);
    q0 = nmDataAttribute("Flow rate", 0.0000, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
};

ConstantPressure::ConstantPressure()
    : isAbandonmentRate(false)
    , isMaximumRate(false)
{
    const QStringList pressureUnits = (QStringList()
        << "MPa" << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2"
        << "psig" << "bar" << "kPag");

    const QStringList flowRateUnits = (QStringList()
        << "B/D" << "MMm^3/D" << "Mcf/D" << "Mm^3/D" << "Mm^3/hr"
        << "U.K. gal/hr" << "U.K. gal/min" << "U.S. gal/hr" << "U.S. gal/min"
        << "cf/D" << "cf/s" << "cm^3/sec" << "l/min"
        << "m^3/D" << "m^3/hr" << "m^3/min" << "m^3/sec");

    const QStringList timeUnits = (QStringList()
        << "ms" << "sec" << "min" << "hr" << "day"
        << "Week" << "week" << "Month" << "month" << "Year" << "year");

    initialPressure = nmDataAttribute("Initial pressure", 317.958, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
    abandonmentRate = nmDataAttribute("Abandonment rate", 0.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
    maximumRate = nmDataAttribute("Maximum rate", 50000.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
    forecastDuration = nmDataAttribute("Forecast duration", 365.0, "day", UNIT_TYPE_TIME, QStringList(), timeUnits);
    producingPressure = nmDataAttribute("Producing pressure", 23.0460, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
}

// Getter and Setter for initialPressure
nmDataAttribute& ConstantPressure::getInitialPressure() {
    return initialPressure;
}

void ConstantPressure::setInitialPressure(const nmDataAttribute& value) {
    initialPressure = value;
}

// Getter and Setter for abandonmentRate
nmDataAttribute& ConstantPressure::getAbandonmentRate() {
    return abandonmentRate;
}

void ConstantPressure::setAbandonmentRate(const nmDataAttribute& value) {
    abandonmentRate = value;
}

// Getter and Setter for isAbandonmentRate
bool ConstantPressure::getIsAbandonmentRate() const {
    return isAbandonmentRate;
}

void ConstantPressure::setIsAbandonmentRate(bool value) {
    isAbandonmentRate = value;
}

// Getter and Setter for maximumRate
nmDataAttribute& ConstantPressure::getMaximumRate() {
    return maximumRate;
}

void ConstantPressure::setMaximumRate(const nmDataAttribute& value) {
    maximumRate = value;
}

// Getter and Setter for isMaximumRate
bool ConstantPressure::getIsMaximumRate() const {
    return isMaximumRate;
}

void ConstantPressure::setIsMaximumRate(bool value) {
    isMaximumRate = value;
}

// Getter and Setter for forecastDuration
nmDataAttribute& ConstantPressure::getForecastDuration() {
    return forecastDuration;
}

void ConstantPressure::setForecastDuration(const nmDataAttribute& value) {
    forecastDuration = value;
}

// Getter and Setter for producingPressure
nmDataAttribute& ConstantPressure::getProducingPressure() {
    return producingPressure;
}

void ConstantPressure::setProducingPressure(const nmDataAttribute& value) {
    producingPressure = value;
}

DecliningPressure::DecliningPressure()
    : isAbandonmentRate(false)
    , isMaximumRate(false)
{
    const QStringList pressureUnits = (QStringList()
        << "MPa" << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2"
        << "psig" << "bar" << "kPag");

    const QStringList flowRateUnits = (QStringList()
        << "B/D" << "MMm^3/D" << "Mcf/D" << "Mm^3/D" << "Mm^3/hr"
        << "U.K. gal/hr" << "U.K. gal/min" << "U.S. gal/hr" << "U.S. gal/min"
        << "cf/D" << "cf/s" << "cm^3/sec" << "l/min"
        << "m^3/D" << "m^3/hr" << "m^3/min" << "m^3/sec");

    const QStringList timeUnits = (QStringList()
        << "ms" << "sec" << "min" << "hr" << "day"
        << "Week" << "week" << "Month" << "month" << "Year" << "year");

    initialPressure = nmDataAttribute("Initial pressure", 317.958, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
    abandonmentRate = nmDataAttribute("Abandonment rate", 0.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
    maximumRate     = nmDataAttribute("Maximum rate", 50000.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
    forecastDuration = nmDataAttribute("Forecast duration", 365.0, "day", UNIT_TYPE_TIME, QStringList(), timeUnits);
    producingPressureStart = nmDataAttribute("Producing pressure (start)", 23.0460, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
    producingPressureEnd   = nmDataAttribute("Producing pressure (end)",   20.0, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
    pressureChangePeriod   = nmDataAttribute("Pressure change period", 30.0, "day", UNIT_TYPE_TIME, QStringList(), timeUnits);
}

// Getter and Setter for initialPressure
nmDataAttribute& DecliningPressure::getInitialPressure() {
    return initialPressure;
}

void DecliningPressure::setInitialPressure(const nmDataAttribute& value) {
    initialPressure = value;
}

// Getter and Setter for abandonmentRate
nmDataAttribute& DecliningPressure::getAbandonmentRate() {
    return abandonmentRate;
}

void DecliningPressure::setAbandonmentRate(const nmDataAttribute& value) {
    abandonmentRate = value;
}

// Getter and Setter for isAbandonmentRate
bool DecliningPressure::getIsAbandonmentRate() const {
    return isAbandonmentRate;
}

void DecliningPressure::setIsAbandonmentRate(bool value) {
    isAbandonmentRate = value;
}

// Getter and Setter for maximumRate
nmDataAttribute& DecliningPressure::getMaximumRate() {
    return maximumRate;
}

void DecliningPressure::setMaximumRate(const nmDataAttribute& value) {
    maximumRate = value;
}

// Getter and Setter for isMaximumRate
bool DecliningPressure::getIsMaximumRate() const {
    return isMaximumRate;
}

void DecliningPressure::setIsMaximumRate(bool value) {
    isMaximumRate = value;
}

// Getter and Setter for forecastDuration
nmDataAttribute& DecliningPressure::getForecastDuration() {
    return forecastDuration;
}

void DecliningPressure::setForecastDuration(const nmDataAttribute& value) {
    forecastDuration = value;
}

// Getter and Setter for producingPressureStart
nmDataAttribute& DecliningPressure::getProducingPressureStart() {
    return producingPressureStart;
}

void DecliningPressure::setProducingPressureStart(const nmDataAttribute& value) {
    producingPressureStart = value;
}

// Getter and Setter for producingPressureEnd
nmDataAttribute& DecliningPressure::getProducingPressureEnd() {
    return producingPressureEnd;
}

void DecliningPressure::setProducingPressureEnd(const nmDataAttribute& value) {
    producingPressureEnd = value;
}

// Getter and Setter for pressureChangePeriod
nmDataAttribute& DecliningPressure::getPressureChangePeriod() {
    return pressureChangePeriod;
}

void DecliningPressure::setPressureChangePeriod(const nmDataAttribute& value) {
    pressureChangePeriod = value;
}

MultiplePressures::MultiplePressures()
    : isAbandonmentRate(false)
    , isMaximumRate(false)
{
    const QStringList pressureUnits = (QStringList()
        << "MPa" << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2"
        << "psig" << "bar" << "kPag");

    const QStringList flowRateUnits = (QStringList()
        << "B/D" << "MMm^3/D" << "Mcf/D" << "Mm^3/D" << "Mm^3/hr"
        << "U.K. gal/hr" << "U.K. gal/min" << "U.S. gal/hr" << "U.S. gal/min"
        << "cf/D" << "cf/s" << "cm^3/sec" << "l/min"
        << "m^3/D" << "m^3/hr" << "m^3/min" << "m^3/sec");

    initialPressure = nmDataAttribute("Initial pressure", 317.958, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);
    abandonmentRate = nmDataAttribute("Abandonment rate", 0.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);
    maximumRate     = nmDataAttribute("Maximum rate",     50000.0, "B/D", UNIT_TYPE_FLOW_RATE, QStringList(), flowRateUnits);

    pressureTable.append(PressureRow());
}

// Getter and Setter for initialPressure
nmDataAttribute& MultiplePressures::getInitialPressure() {
    return initialPressure;
}

void MultiplePressures::setInitialPressure(const nmDataAttribute& value) {
    initialPressure = value;
}

// Getter and Setter for abandonmentRate
nmDataAttribute& MultiplePressures::getAbandonmentRate() {
    return abandonmentRate;
}

void MultiplePressures::setAbandonmentRate(const nmDataAttribute& value) {
    abandonmentRate = value;
}

// Getter and Setter for isAbandonmentRate
bool MultiplePressures::getIsAbandonmentRate() const {
    return isAbandonmentRate;
}
void MultiplePressures::setIsAbandonmentRate(bool value) {
    isAbandonmentRate = value;
}

// Getter and Setter for maximumRate
nmDataAttribute& MultiplePressures::getMaximumRate() {
    return maximumRate;
}

void MultiplePressures::setMaximumRate(const nmDataAttribute& value) {
    maximumRate = value;
}

// Getter and Setter for isMaximumRate
bool MultiplePressures::getIsMaximumRate() const {
    return isMaximumRate;
}

void MultiplePressures::setIsMaximumRate(bool value) {
    isMaximumRate = value;
}

// Getter/Setter for pressureTable
QVector<PressureRow>& MultiplePressures::getPressureTable() {
    return pressureTable;
}

void MultiplePressures::setPressureTable(const QVector<PressureRow>& table) {
    pressureTable = table;
}

MultipleRates::MultipleRates()
{
    const QStringList pressureUnits = (QStringList()
        << "MPa" << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2"
        << "psig" << "bar" << "kPag");

    initialPressure = nmDataAttribute("Initial pressure", 317.958, "psia", UNIT_TYPE_PRESSURE, QStringList(), pressureUnits);

    flowTable.append(FlowRow());
}

// Getter and Setter for initialPressure
nmDataAttribute& MultipleRates::getInitialPressure() {
    return initialPressure;
}

void MultipleRates::setInitialPressure(const nmDataAttribute& value) {
    initialPressure = value;
}

// Getter/Setter for flowTable
QVector<FlowRow>& MultipleRates::getFlowTable() {
    return flowTable;
}

void MultipleRates::setFlowTable(const QVector<FlowRow>& table) {
    flowTable = table;
}

nmDataForecast::nmDataForecast() : currentOption(ConstantPressureOption) {}

nmDataForecast::~nmDataForecast() {}

nmDataForecast::nmDataForecast(const nmDataForecast& other) {
    *this = other; //    ? ?     ?   ?
}

nmDataForecast& nmDataForecast::operator=(const nmDataForecast& other) {
    if (this != &other) {
        currentOption = other.currentOption;
        constantPressureData = other.constantPressureData;
        decliningPressureData = other.decliningPressureData;
        multiplePressuresData  = other.multiplePressuresData;
        multipleRatesData = other.multipleRatesData;
    }
    return *this;
}

rapidjson::Value nmDataForecast::ToJsonValue(rapidjson::Document::AllocatorType& allocator) const
{
    rapidjson::Value root(rapidjson::kObjectType);

    root.AddMember("ForecastOption", static_cast<int>(currentOption), allocator);

    if (currentOption == ConstantPressureOption)
    {
        rapidjson::Value cp(rapidjson::kObjectType);

        cp.AddMember("InitialPressure",   constantPressureData.initialPressure.ToJsonValue(allocator), allocator);
        cp.AddMember("AbandonmentRate",   constantPressureData.abandonmentRate.ToJsonValue(allocator), allocator);
        cp.AddMember("IsAbandonmentRate", constantPressureData.isAbandonmentRate, allocator);
        cp.AddMember("MaximumRate",       constantPressureData.maximumRate.ToJsonValue(allocator), allocator);
        cp.AddMember("IsMaximumRate",     constantPressureData.isMaximumRate, allocator);
        cp.AddMember("ForecastDuration",  constantPressureData.forecastDuration.ToJsonValue(allocator), allocator);
        cp.AddMember("ProducingPressure", constantPressureData.producingPressure.ToJsonValue(allocator), allocator);

        root.AddMember("ConstantPressureData", cp, allocator);
    }
    else if (currentOption == DecliningPressureOption)
    {
        rapidjson::Value dp(rapidjson::kObjectType);

        dp.AddMember("InitialPressure",        decliningPressureData.initialPressure.ToJsonValue(allocator), allocator);
        dp.AddMember("AbandonmentRate",        decliningPressureData.abandonmentRate.ToJsonValue(allocator), allocator);
        dp.AddMember("IsAbandonmentRate",      decliningPressureData.isAbandonmentRate, allocator);
        dp.AddMember("MaximumRate",            decliningPressureData.maximumRate.ToJsonValue(allocator), allocator);
        dp.AddMember("IsMaximumRate",          decliningPressureData.isMaximumRate, allocator);
        dp.AddMember("ForecastDuration",       decliningPressureData.forecastDuration.ToJsonValue(allocator), allocator);
        dp.AddMember("ProducingPressureStart", decliningPressureData.producingPressureStart.ToJsonValue(allocator), allocator);
        dp.AddMember("ProducingPressureEnd",   decliningPressureData.producingPressureEnd.ToJsonValue(allocator), allocator);
        dp.AddMember("PressureChangePeriod",   decliningPressureData.pressureChangePeriod.ToJsonValue(allocator), allocator);

        root.AddMember("DecliningPressureData", dp, allocator);
    }
    else if (currentOption == MultiplePressuresOption)
    {
        rapidjson::Value mp(rapidjson::kObjectType);

        mp.AddMember("InitialPressure",   multiplePressuresData.initialPressure.ToJsonValue(allocator), allocator);
        mp.AddMember("AbandonmentRate",   multiplePressuresData.abandonmentRate.ToJsonValue(allocator), allocator);
        mp.AddMember("IsAbandonmentRate", multiplePressuresData.isAbandonmentRate, allocator);
        mp.AddMember("MaximumRate",       multiplePressuresData.maximumRate.ToJsonValue(allocator), allocator);
        mp.AddMember("IsMaximumRate",     multiplePressuresData.isMaximumRate, allocator);

        // PressureTable:
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.Reserve(static_cast<rapidjson::SizeType>(multiplePressuresData.pressureTable.size()), allocator);
        for (int i = 0; i < multiplePressuresData.pressureTable.size(); ++i) {
            const PressureRow& row = multiplePressuresData.pressureTable[i];
            rapidjson::Value rowObj(rapidjson::kObjectType);
            rowObj.AddMember("Duration", row.duration.ToJsonValue(allocator), allocator);
            rowObj.AddMember("Pressure", row.pressure.ToJsonValue(allocator), allocator);
            arr.PushBack(rowObj, allocator);
        }
        mp.AddMember("PressureTable", arr, allocator);

        root.AddMember("MultiplePressuresData", mp, allocator);
    }
    else if (currentOption == MultipleRatesOption)
    {
        rapidjson::Value mr(rapidjson::kObjectType);

        mr.AddMember("InitialPressure", multipleRatesData.initialPressure.ToJsonValue(allocator), allocator);

        // FlowTable:
        rapidjson::Value arr(rapidjson::kArrayType);
        arr.Reserve(static_cast<rapidjson::SizeType>(multipleRatesData.flowTable.size()), allocator);
        for (int i = 0; i < multipleRatesData.flowTable.size(); ++i) {
            const FlowRow& row = multipleRatesData.flowTable[i];
            rapidjson::Value rowObj(rapidjson::kObjectType);
            rowObj.AddMember("Duration", row.duration.ToJsonValue(allocator), allocator);
            rowObj.AddMember("Q0", row.q0.ToJsonValue(allocator), allocator);
            arr.PushBack(rowObj, allocator);
        }
        mr.AddMember("FlowTable", arr, allocator);

        root.AddMember("MultipleRatesData", mr, allocator);
    }

    return root;
}

void nmDataForecast::FromJsonValue(const rapidjson::Value& jsonValue)
{
    if (!jsonValue.IsObject())
        return;

    if (jsonValue.HasMember("ForecastOption"))
        currentOption = static_cast<ForecastOption>(jsonValue["ForecastOption"].GetInt());

    if (currentOption == ConstantPressureOption && jsonValue.HasMember("ConstantPressureData"))
    {
        const rapidjson::Value& cp = jsonValue["ConstantPressureData"];
        if (cp.IsObject())
        {
            if (cp.HasMember("InitialPressure"))   constantPressureData.initialPressure.FromJsonValue(cp["InitialPressure"]);
            if (cp.HasMember("AbandonmentRate"))   constantPressureData.abandonmentRate.FromJsonValue(cp["AbandonmentRate"]);
            if (cp.HasMember("IsAbandonmentRate")) constantPressureData.isAbandonmentRate = cp["IsAbandonmentRate"].GetBool();
            if (cp.HasMember("MaximumRate"))       constantPressureData.maximumRate.FromJsonValue(cp["MaximumRate"]);
            if (cp.HasMember("IsMaximumRate"))     constantPressureData.isMaximumRate = cp["IsMaximumRate"].GetBool();
            if (cp.HasMember("ForecastDuration"))  constantPressureData.forecastDuration.FromJsonValue(cp["ForecastDuration"]);
            if (cp.HasMember("ProducingPressure")) constantPressureData.producingPressure.FromJsonValue(cp["ProducingPressure"]);
        }
    }
    else if (currentOption == DecliningPressureOption && jsonValue.HasMember("DecliningPressureData"))
    {
        const rapidjson::Value& dp = jsonValue["DecliningPressureData"];
        if (dp.IsObject())
        {
            if (dp.HasMember("InitialPressure"))        decliningPressureData.initialPressure.FromJsonValue(dp["InitialPressure"]);
            if (dp.HasMember("AbandonmentRate"))        decliningPressureData.abandonmentRate.FromJsonValue(dp["AbandonmentRate"]);
            if (dp.HasMember("IsAbandonmentRate"))      decliningPressureData.isAbandonmentRate = dp["IsAbandonmentRate"].GetBool();
            if (dp.HasMember("MaximumRate"))            decliningPressureData.maximumRate.FromJsonValue(dp["MaximumRate"]);
            if (dp.HasMember("IsMaximumRate"))          decliningPressureData.isMaximumRate = dp["IsMaximumRate"].GetBool();
            if (dp.HasMember("ForecastDuration"))       decliningPressureData.forecastDuration.FromJsonValue(dp["ForecastDuration"]);
            if (dp.HasMember("ProducingPressureStart")) decliningPressureData.producingPressureStart.FromJsonValue(dp["ProducingPressureStart"]);
            if (dp.HasMember("ProducingPressureEnd"))   decliningPressureData.producingPressureEnd.FromJsonValue(dp["ProducingPressureEnd"]);
            if (dp.HasMember("PressureChangePeriod"))   decliningPressureData.pressureChangePeriod.FromJsonValue(dp["PressureChangePeriod"]);
        }
    }
    else if (currentOption == MultiplePressuresOption && jsonValue.HasMember("MultiplePressuresData"))
    {
        const rapidjson::Value& mp = jsonValue["MultiplePressuresData"];
        if (mp.IsObject())
        {
            if (mp.HasMember("InitialPressure"))   multiplePressuresData.initialPressure.FromJsonValue(mp["InitialPressure"]);
            if (mp.HasMember("AbandonmentRate"))   multiplePressuresData.abandonmentRate.FromJsonValue(mp["AbandonmentRate"]);
            if (mp.HasMember("IsAbandonmentRate")) multiplePressuresData.isAbandonmentRate = mp["IsAbandonmentRate"].GetBool();
            if (mp.HasMember("MaximumRate"))       multiplePressuresData.maximumRate.FromJsonValue(mp["MaximumRate"]);
            if (mp.HasMember("IsMaximumRate"))     multiplePressuresData.isMaximumRate = mp["IsMaximumRate"].GetBool();

            multiplePressuresData.pressureTable.clear();
            if (mp.HasMember("PressureTable") && mp["PressureTable"].IsArray())
            {
                const auto& arr = mp["PressureTable"].GetArray();
                multiplePressuresData.pressureTable.reserve(static_cast<int>(arr.Size()));
                for (rapidjson::SizeType i = 0; i < arr.Size(); ++i)
                {
                    const rapidjson::Value& rowObj = arr[i];
                    if (!rowObj.IsObject()) continue;

                    PressureRow row;
                    if (rowObj.HasMember("Duration")) row.duration.FromJsonValue(rowObj["Duration"]);
                    if (rowObj.HasMember("Pressure")) row.pressure.FromJsonValue(rowObj["Pressure"]);
                    multiplePressuresData.pressureTable.push_back(row);
                }
            }
        }
    }
    else if (currentOption == MultipleRatesOption && jsonValue.HasMember("MultipleRatesData"))
    {
        const rapidjson::Value& mr = jsonValue["MultipleRatesData"];
        if (mr.IsObject())
        {
            if (mr.HasMember("InitialPressure")) multipleRatesData.initialPressure.FromJsonValue(mr["InitialPressure"]);

            multipleRatesData.flowTable.clear();
            if (mr.HasMember("FlowTable") && mr["FlowTable"].IsArray())
            {
                const auto& arr = mr["FlowTable"].GetArray();
                multipleRatesData.flowTable.reserve(static_cast<int>(arr.Size()));
                for (rapidjson::SizeType i = 0; i < arr.Size(); ++i)
                {
                    const rapidjson::Value& rowObj = arr[i];
                    if (!rowObj.IsObject()) continue;

                    FlowRow row;
                    if (rowObj.HasMember("Duration")) row.duration.FromJsonValue(rowObj["Duration"]);
                    if (rowObj.HasMember("Q0")) row.q0.FromJsonValue(rowObj["Q0"]);
                    multipleRatesData.flowTable.push_back(row);
                }
            }
        }
    }
}


void nmDataForecast::setForecastOption(ForecastOption option) {
    currentOption = option;
}

nmDataForecast::ForecastOption nmDataForecast::getForecastOption() const {
    return currentOption;
}

void nmDataForecast::setConstantPressureData(const ConstantPressure& cp) {
    constantPressureData = cp;
}

ConstantPressure& nmDataForecast::getConstantPressureData() {
    return constantPressureData;
}

void nmDataForecast::setDecliningPressureData(const DecliningPressure& dp) {
    decliningPressureData = dp;
}

DecliningPressure& nmDataForecast::getDecliningPressureData() {
    return decliningPressureData;
}

void nmDataForecast::setMultiplePressuresData(const MultiplePressures& mp) {
    multiplePressuresData = mp;
}

MultiplePressures& nmDataForecast::getMultiplePressuresData() {
    return multiplePressuresData;
}

void nmDataForecast::setMultipleRatesData(const MultipleRates& mp) {
    multipleRatesData = mp;
}

MultipleRates& nmDataForecast::getMultipleRatesData() {
    return multipleRatesData;
}