From 5c0c56e165a674ffb5f92c12438b27c2ca97e338 Mon Sep 17 00:00:00 2001 From: sysadmin Date: Thu, 11 Jan 2024 11:24:19 -0800 Subject: [PATCH 001/115] Add measurement unit output API --- src/EnergyPlus/DataGlobalConstants.hh | 15 +++++- src/EnergyPlus/api/datatransfer.cc | 72 +++++++++++++++++++++------ src/EnergyPlus/api/datatransfer.h | 3 ++ src/EnergyPlus/api/datatransfer.py | 11 ++-- 4 files changed, 83 insertions(+), 18 deletions(-) diff --git a/src/EnergyPlus/DataGlobalConstants.hh b/src/EnergyPlus/DataGlobalConstants.hh index 2fe7154231f..9dd322d6bfa 100644 --- a/src/EnergyPlus/DataGlobalConstants.hh +++ b/src/EnergyPlus/DataGlobalConstants.hh @@ -363,7 +363,7 @@ namespace Constant { eResourceNames[(int)eFuel2eResource[(int)eFuel::Water]], eResourceNames[(int)eFuel2eResource[(int)eFuel::None]]}; - enum class Units + enum class Units : signed int { Invalid = -1, kg_s, @@ -474,6 +474,19 @@ namespace Constant { "customEMS" // customEMS }; + inline std::string unitToString(Units unit) { + switch (unit) { + case Units::Invalid: + return "invalid"; + default: + if (!(0 <= (int)unit + && (int)unit < (int)unitNames.size())) + { return "invalid-out-of-range"; } + return std::string{unitNames[(unsigned int)unit]}; + } + return ""; + } + constexpr std::array unitNamesUC = { "KG/S", // kg_s "C", // C diff --git a/src/EnergyPlus/api/datatransfer.cc b/src/EnergyPlus/api/datatransfer.cc index f828246ad68..276b37f67c0 100644 --- a/src/EnergyPlus/api/datatransfer.cc +++ b/src/EnergyPlus/api/datatransfer.cc @@ -52,6 +52,7 @@ #include #include +#include #include #include #include @@ -73,43 +74,73 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) std::string name; std::string type; std::string key; - LocalAPIDataEntry(std::string _what, std::string _name, std::string _key, std::string _type) - : what(std::move(_what)), name(std::move(_name)), type(std::move(_type)), key(std::move(_key)) + std::string unit; + LocalAPIDataEntry(std::string _what, std::string _name, std::string _key, std::string _type, std::string _unit) + : what(std::move(_what)), name(std::move(_name)), type(std::move(_type)), key(std::move(_key)), unit(std::move(_unit)) { } }; std::vector localDataEntries; auto *thisState = reinterpret_cast(state); for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { - if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { + if (availActuator.ComponentTypeName.empty() + && availActuator.UniqueIDName.empty() + && availActuator.ControlTypeName.empty()) + { break; } - localDataEntries.emplace_back("Actuator", availActuator.ComponentTypeName, availActuator.ControlTypeName, availActuator.UniqueIDName); + localDataEntries.emplace_back( + "Actuator", + availActuator.ComponentTypeName, + availActuator.ControlTypeName, + availActuator.UniqueIDName, + availActuator.Units + ); } for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { if (availVariable.DataTypeName.empty() && availVariable.UniqueIDName.empty()) { break; } - localDataEntries.emplace_back("InternalVariable", availVariable.DataTypeName, "", availVariable.UniqueIDName); + localDataEntries.emplace_back( + "InternalVariable", + availVariable.DataTypeName, + "", + availVariable.UniqueIDName, + availVariable.Units + ); } for (auto const &gVarName : thisState->dataPluginManager->globalVariableNames) { - localDataEntries.emplace_back("PluginGlobalVariable", "", "", gVarName); + localDataEntries.emplace_back("PluginGlobalVariable", "", "", gVarName, ""); } for (auto const &trend : thisState->dataPluginManager->trends) { - localDataEntries.emplace_back("PluginTrendVariable,", "", "", trend.name); + localDataEntries.emplace_back("PluginTrendVariable,", "", "", trend.name, ""); } for (auto const *meter : thisState->dataOutputProcessor->meters) { if (meter->Name.empty()) { break; } - localDataEntries.emplace_back("OutputMeter", "", "", meter->Name); + localDataEntries.emplace_back( + "OutputMeter", + "", + "", + meter->Name, + EnergyPlus::Constant::unitToString(meter->units) + ); } for (auto const *variable : thisState->dataOutputProcessor->outVars) { if (variable->varType != EnergyPlus::OutputProcessor::VariableType::Real) continue; if (variable->name.empty() && variable->keyUC.empty()) { break; } - localDataEntries.emplace_back("OutputVariable", variable->name, "", variable->keyUC); + localDataEntries.emplace_back( + "OutputVariable", + variable->name, + "", + variable->keyUC, + variable->units == EnergyPlus::Constant::Units::customEMS + ? variable->unitNameCustomEMS + : EnergyPlus::Constant::unitToString(variable->units) + ); } *resultingSize = localDataEntries.size(); auto *data = new APIDataEntry[*resultingSize]; @@ -122,6 +153,8 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) std::strcpy(data[i].key, localDataEntries[i].key.c_str()); data[i].type = new char[std::strlen(localDataEntries[i].type.c_str()) + 1]; std::strcpy(data[i].type, localDataEntries[i].type.c_str()); + data[i].unit = new char[std::strlen(localDataEntries[i].unit.c_str()) + 1]; + std::strcpy(data[i].unit, localDataEntries[i].unit.c_str()); } return data; } @@ -133,6 +166,7 @@ void freeAPIData(struct APIDataEntry *data, unsigned int arraySize) delete[] data[i].name; delete[] data[i].key; delete[] data[i].type; + delete[] data[i].unit; } delete[] data; } @@ -148,7 +182,8 @@ char *listAllAPIDataCSV(EnergyPlusState state) output.append("Actuator,"); output.append(availActuator.ComponentTypeName).append(","); output.append(availActuator.ControlTypeName).append(","); - output.append(availActuator.UniqueIDName).append("\n"); + output.append(availActuator.UniqueIDName).append(","); + output.append(availActuator.Units).append("\n"); } output.append("**INTERNAL_VARIABLES**\n"); for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { @@ -157,7 +192,8 @@ char *listAllAPIDataCSV(EnergyPlusState state) } output.append("InternalVariable,"); output.append(availVariable.DataTypeName).append(","); - output.append(availVariable.UniqueIDName).append("\n"); + output.append(availVariable.UniqueIDName).append(","); + output.append(availVariable.Units).append("\n"); } output.append("**PLUGIN_GLOBAL_VARIABLES**\n"); for (auto const &gVarName : thisState->dataPluginManager->globalVariableNames) { @@ -174,8 +210,11 @@ char *listAllAPIDataCSV(EnergyPlusState state) if (meter->Name.empty()) { break; } - output.append("OutputMeter,"); - output.append(meter->Name).append("\n"); + output.append("OutputMeter").append(","); + output.append(meter->Name).append(","); + output.append( + EnergyPlus::Constant::unitToString(meter->units) + ).append("\n"); } output.append("**VARIABLES**\n"); for (auto const *variable : thisState->dataOutputProcessor->outVars) { @@ -185,7 +224,12 @@ char *listAllAPIDataCSV(EnergyPlusState state) } output.append("OutputVariable,"); output.append(variable->name).append(","); - output.append(variable->keyUC).append("\n"); + output.append(variable->keyUC).append(","); + output.append( + variable->units == EnergyPlus::Constant::Units::customEMS + ? variable->unitNameCustomEMS + : EnergyPlus::Constant::unitToString(variable->units) + ).append("\n"); } // note that we cannot just return a c_str to the local string, as the string will be destructed upon leaving // this function, and undefined behavior will occur. diff --git a/src/EnergyPlus/api/datatransfer.h b/src/EnergyPlus/api/datatransfer.h index e35ebe03451..1cae1cf7015 100644 --- a/src/EnergyPlus/api/datatransfer.h +++ b/src/EnergyPlus/api/datatransfer.h @@ -89,6 +89,9 @@ struct APIDataEntry /// \details This is only used for actuators, and represents the control actuation. /// For a node setpoint actuation, this could be either temperature or humidity, for example. char *type; // only used for actuators + /// \brief This represents the unit of measurement for this exchange point. + /// \details This is only used for non-plugin variables. + char *unit; // NOT used for plugin variables }; /// \brief Gets available API data for the current simulation diff --git a/src/EnergyPlus/api/datatransfer.py b/src/EnergyPlus/api/datatransfer.py index e2b8ee1c5f8..4c8964839ae 100644 --- a/src/EnergyPlus/api/datatransfer.py +++ b/src/EnergyPlus/api/datatransfer.py @@ -85,7 +85,7 @@ class DataExchange: """ class _APIDataEntry(Structure): - _fields_ = [("what", c_char_p),("name", c_char_p),("key", c_char_p),("type", c_char_p),] + _fields_ = [("what", c_char_p),("name", c_char_p),("key", c_char_p),("type", c_char_p),("unit", c_char_p)] class APIDataExchangePoint: """ @@ -93,7 +93,7 @@ class APIDataExchangePoint: class could represent output variables, output meters, actuators, and more. The "type" member variable can be used to filter a specific type. """ - def __init__(self, _what: str, _name: str, _key: str, _type: str): + def __init__(self, _what: str, _name: str, _key: str, _type: str, _unit: str): #: This variable will hold the basic type of API data point, in string form. #: This can be one of the following: "Actuator", "InternalVariable", "PluginGlobalVariable", #: "PluginTrendVariable", "OutputMeter", or "OutputVariable". Once the full list of data exchange points @@ -110,6 +110,9 @@ def __init__(self, _what: str, _name: str, _key: str, _type: str): #: and represents the control actuation. For a node setpoint actuation, this could be "temperature" or #: "humidity", for example. self.type: str = _type + #: This represents the unit of measure for this exchange point. + #: This is NOT used for plugin variables such as PluginGlobalVariable and PluginTrendVariable. + self.unit: str = _unit def __init__(self, api: cdll, running_as_python_plugin: bool = False): """ @@ -299,7 +302,9 @@ def get_api_data(self, state: c_void_p) -> List[APIDataExchangePoint]: r[i].what.decode('utf-8'), r[i].name.decode('utf-8'), r[i].key.decode('utf-8'), - r[i].type.decode('utf-8')) for i in range(count.value) + r[i].type.decode('utf-8'), + r[i].unit.decode('utf-8'), + ) for i in range(count.value) ] self.api.freeAPIData(r, count) # free the underlying C memory now that we have a Python copy return list_response From bb3267579f54c07cab54c1f747b64a928e96f89e Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 18 Jan 2024 13:42:03 -0600 Subject: [PATCH 002/115] Add initial NFP for ruleset model description support [decent_ci_skip] [actions skip] --- .../NFP-RulesetModelDescriptionPhase3.md | 639 ++++++++++++++++++ 1 file changed, 639 insertions(+) create mode 100644 design/FY2024/NFP-RulesetModelDescriptionPhase3.md diff --git a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md new file mode 100644 index 00000000000..2ff6d9ff2e0 --- /dev/null +++ b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md @@ -0,0 +1,639 @@ +Ruleset Model Description Phase 3 +================ + +**Jason Glazer, GARD Analytics** + + - January 18, 2024 + +## Justification for New Feature ## + +This continues the work from 2022 and 2023 to develop the createRMD script that creates a JSON file consistent with the +ASHRAE Standard 229 Ruleset Model Description schema to show the feasibility of the schema, uncover problems with +implementation, and provide an implementation for early adopters. The goal is to provide an RMD file that fully supports +the data currently used by PNNL Ruleset Checking Tool. The repo for the script development is here: + +https://github.com/JasonGlazer/createRulesetModelDescription + +The title, purpose, and scope of ASHRAE Standard 229 are: + +Title: + +- Protocols for Evaluating Ruleset Application in Building Performance Models + +Purpose: + +- This standard establishes tests and acceptance criteria for application of rulesets and related reporting for building +performance models. + +Scope: + +- This standard applies to evaluation of the implementation of rulesets associated with new or existing buildings, their +systems, controls, sites, and other aspects described by the ruleset. It establishes requirements for: +- 2.1 building performance modeling software +- 2.2 software that evaluates building performance models and associated information to check the application of a ruleset + +ASHRAE Standard 229 has not been published and is under development by the ASHRAE SPC 229P committee which is expecting +a public review shortly. The intention of the standard is to provide code officials and rating authorities with files +that they can use with a Ruleset Checking Tool (currently, an example is under development at PNNL) to automatically +check if a ruleset (such as 90.1 Appendix G, RESNET, California Title 24 performance paths, or Canada National Energy +Code for Buildings performance path) has been implemented correctly. Since each EnergyPlus IDF file could generate an +RMD file, the Ruleset Checking Tool will be able to see if the changes between the RMD files correspond to rules in +the ruleset by looking at both the baseline and proposed RMD file. + +The schema is described here: + +https://github.com/open229/ruleset-model-description-schema/blob/main/schema-source/ASHRAE229_extra.schema.yaml + +## E-mail and Conference Call Conclusions ## + +no discussion yet + +## Overview ## + +The initial phase was on focused on data groups describing the building envelope and internal loads. The second phase added +support for some HVAC data groups and elements. This phase will continue working on the HVAC data groups and elements. The +PNNL Ruleset Checking Tool (RCT) supports evaluation of rules using many data groups but does not evaluate all data groups. +The data groups that are not included are related to refrigeration, elevators, SWH, transformers, district and data validation +points. These excluded data groups will not be supported in this phase of development for createRMD. + +For this phase, the focus is on: + +- implementing additional output reports in EnergyPlus +- filling in gaps in existing data groups +- supporting more data groups +- methods to merge compliance parameters + +Targeted data groups from the 229 RMD Schema for this effort are the HVAC portion of the schema: + +- HeatingVentilatingAirConditioningSystem +- HeatingSystem +- CoolingSystem +- FanSystem +- AirEconomizer +- AirEnergyRecovery +- Fan +- Terminal +- FluidLoop +- FluidLoopDesignAndControl +- Pump +- Boiler +- Chiller +- HeatRejection + +This effort will focus on trying to implement as many data groups and elements as possible with the expectation to support +all the data elements used by the PNNL Ruleset Checking Tool. + +Since this NFP builds on the efforts described in previous NFPs, some details are skipped that are already described in those +ealier NFPs: + +https://github.com/NREL/EnergyPlus/blob/develop/design/FY2022/NFP-InitialRulesetModelDescription.md + +https://github.com/NREL/EnergyPlus/blob/develop/design/FY2023/NFP-RulesetModelDescriptionPhase2.md + +Some lessons learned from the initial effort in initial 2022 are described here: + +https://github.com/JasonGlazer/createRulesetModelDescription/blob/main/docs/lessons_learned.rst + +## Approach ## + +The effort will continue the approach used in 2022 and 2023 development of the createRMD but +will add more reporting to EnergyPlus to be consistent with the goal of being driven by EnergyPlus +outputs and not needing to read the IDF or epJSON files. The approach has two focuses: + +- Enhance EnergyPlus Tabular Output Reports +- Support New Data Groups in createRMD Python script + +In addition, selected fixes of the createRMD Python script will be incorporated from the current list of issues +in the repository. + +To understand how when data elements can be populated by either EnergyPlus input or EnergyPlus output as the +source of the RMD data elements, a specially tagged version of the schema file was created here: + +https://github.com/open229/ruleset-model-description-schema/blob/EPtags/schema-source/ASHRAE229_extra.schema.yaml + +Tags added are: + +- Used by RCT Test +- EPin Object +- EPin Field +- EPout File +- EPout Report +- EPout Table +- EPout Column +- EPstatus +- EP Notes + +The goal of this task is to support all the data groups and data elements currently used by the PNNL Ruleset Checking +Tool. If that is not possible within the budget of this task, a focus will be made on data elements and data groups +used most often. + +The following sections describe enhancements to the existing reports and new reports that will be added in EnergyPlus + +### Enhance Existing EnergyPlus Tabular Output Reports ### + +#### Equipment Summary - Heating Coils #### + +The current columns are: +- Type +- Design Coil Load [W] +- Nominal Total Capacity [W] +- Nominal Efficiency [W/W] +- Used as Supplementary Heat +- Airloop name +- Plantloop name + +The new columns would be: +- Airloop branch name +- Plantloop branch name +- Supplemental heat high shutoff temperature [C] + +#### Equipment Summary - DX Heating Coils #### + +The current columns are: +- DX Heating Coil Type +- High Temperature Heating (net) Rating Capacity [W] +- Low Temperature Heating (net) Rating Capacity [W] +- HSPF [Btu/W-h] +- Region Number +- Minimum Outdoor Dry-Bulb Temperature for Compressor Operation +- Airloop name + +The new columns would be: +- Airloop branch name + +#### Equipment Summary - Fans #### + +The current columns are: +- Type +- Total Efficiency [W/W] +- Delta Pressure [pa] +- Max Air Flow Rate [m3/s] +- Rated Electricity Rate [W] +- Rated Power Per Max Air Flow Rate [W-s/m3] +- Motor Heat In Air Fraction +- Fan Energy Index +- End Use Subcategory +- Design Day Name for Fan Sizing Peak +- Date/Time for Fan Sizing Peak +- Purpose (supply, return, exhaust, relief) +- Is autosized +- Motor efficiency +- Motor heat to zone fraction +- Airloop name + +The new columns would be: +- Occupied operation (cycling, continuous, off) +- Unoccupied operation (cycling, continuous, off) +- Locked out during central heating (yes, no, N/A) +- Motor loss zone name +- Airloop branch name + +#### System Summary - Demand Controlled Ventilation using Controller:MechanicalVentilation #### + +The current columns are: +- Controller:MechanicalVentilation Name +- Outdoor Air Per Person [m3/s-person] +- Outdoor Air Per Area [m3/s-m2] +- Outdoor Air Per Zone [m3/s] +- Outdoor Air ACH [ach] +- Outdoor Air Method +- Outdoor Air Schedule Name +- Air Distribution Effectiveness in Cooling Mode +- Air Distribution Effectiveness in Heating Mode +- Air Distribution Effectiveness Schedule Name + +The new columns would be: +- Type (CO2 Zone/Other) + +#### Coil Sizing Details - Coil Connections #### + +The current columns are: +- Coil Name +- Coil Type +- Coil Location +- HVAC Type +- HVAC Name +- Zone Name(s) +- Supply Fan Name for Coil +- Supply Fan Type for Coil +- Airloop Name +- Plant Name for Coil +- Plant Loop Name + +The new columns would be: +- Airloop Branch Name +- Location count on Airloop Branch +- Plant Branch Name +- Location count on Plantloop Branch + +#### Equipment Summary - PlantLoop or CondenserLoop #### + +The current columns are (need to verify that these are populated): +- name +- type (PlantLoop or CondenserLoop) +- provides heating +- provides cooling +- Maximum Loop Flow Rate +- Minimum Loop Flow Rate + +The new columns would be: +- Total pump power on loop + +#### Equipment Summary - AirTerminals #### + +The current columns are: +- name +- Zone Name +- Minimum Flow +- Minimum Outdoor Flow +- Supply cooling setpoint +- Supply heating setpoint +- Heating capacity +- Cooling capacity + +The new columns would be: +- type of input object +- Heat/Reheat Coil Object Type +- Hot Water Plant Loop Name +- Hot Water Plant Branch Name +- Chilled Water Coil Object Type +- Chilled Water Plant Loop Name +- Chilled Water Plant Branch Name +- Fan Object Type +- Fan Name +- Primary Air Flow Rate +- Secondary Air Flow Rate +- Minimum Flow Schedule Name +- Maximum Flow During Reheat +- Minimum Outdoor Flow Schedule Name +- Temperature control + +#### Equipment Summary - Air Heat Recovery #### + +The current columns are (need to verify that these are populated): +- name +- input object type +- plate/rotary +- Sensible Effectiveness at 100% Heating Air Flow +- Sensible Effectiveness at 100% Cooling Air Flow +- Latent Effectiveness at 100% Heating Air Flow +- Latent Effectiveness at 100% Cooling Air Flow +- Exhaust airflow +- Outdoor airflow + + +### Add New EnergyPlus Tabular Reports and Tables ### + +#### HVAC Topology #### + +HVAC Topology + +This report would consists of many tables, one for each air loop, plant loop, or zone equipment. Each would be in the order of how +the branches appear in the loop and the order of components within each branch. After each splitter would be each branch. + +The columns would be: + +- Side +- Parent Type +- Parent Name +- Component Type +- Component Name +- Connection Type (if time allows) + +The "Side" would be either "Demand" or "Supply" for airloops and plant loops. For zone equipment no "side" column is necessary. + +A "Parent Type" could be: Branch, UnitarySystem, and would be blank for the demand side of airloops. + +The "Component Type" and "Component Name" would usually list equipment or other HVAC components with their names but should also +include Zone and the name of the zone for the demand side of an airloop. + +No node names would be included. + +If time allows, the "Connection Type" would be included for components that have multiple pairs of nodes. The "Connection Type" +would describe the type for that pair of nodes. For example, a water coil with both air and water nodes would say "air" or "water" +as appropriate. A chiller would have "chilled water" and "condenser water" and maybe "heat recovery." For +"PlantEquipmentOperation" it might be "Reference" and for AvailabilityManager it might show as "Sensor" and SetPointManger +might have "setpoint" here. + +For implementation, the following data structures are likely to be used + +- air loops (this is all supply side) DataAirSystems::DefinePrimaryAirSystem PrimaryAirSystems +- state.dataAirSystemsData->PrimaryAirSystems +- state.dataZoneEquip->ZoneEquipList +- state.dataPlnt->VentRepPlant +- state.dataPlnt->VentRepCond +- state.dataZoneEquip->SupplyAirPath +- state.dataZoneEquip->ReturnAirPath +- SimAirServingZones::InitAirLoop for supply/return path indexes to the AirPrimaryLoop struct +- thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathIndex - this gets set in SystemReports::InitEnergyReports +- for connection type, SystemReports::CreateEnergyReportStructure could potentially add calls to predefined reports right in here +as each component gets added to the data structures to deduce connection type + +Eventually, anything in the Energy+.idd that has a \type node field would be represented. + +#### Controls #### + +A new report that includes Setpoint Managers, Controllers, Availability Managers, PlantEquipmentOperation, and components +with control options and identifies the type, where they apply, sense, and control parameters from the input. Need: + +- minimum and maximum setpoint temperatures +- minimum turndown ratio +- schedules +- load ranges +- Setpoint at Outdoor Low Temperature +- Outdoor Low Temperature +- Setpoint at Outdoor High Temperature +- Outdoor High Temperature + +This is probably a series of tables, one for each input object. The report would include the pertinent information, +including the controls, related temperatures, and what they apply to but would generally be limited to what is already +available within the data structure that would be useful to report. Include specifically: + +- Heat Recovery - Operation With Economizer +- Heat Recovery - Supply Air Temperature Control + + +## Testing/Validation/Data Sources ## + +Since the output JSON file needs to comply with a JSON schema, it should be easy to confirm that it is valid. +The Python jsonschema library can be used to confirm that the RMD file is consistent with the schema. Comparison +of input and related outputs should provide the final check if the reporting is being done correctly. + +## Input Output Reference Documentation ## + +While no specific changes for input are expected, we are considering allowing compliance parameters in the IDF/epJSON file by +following the generic tag/properties described in this issue: + +https://github.com/NREL/EnergyPlus/issues/8775 + +Additional tabular outputs will be described in the IOref. + +## createRMD Enhancements ### + +Certain data groups and elements are more important to implement since they are used by PNNL's Ruleset Checking Tool: + +HeatingVentilatingAirConditioningSystem +- preheat_system + +CoolingSystem: +- dehumidification_type + +FanSystem: +- return_fans +- exhaust_fans +- relief_fans +- air_economizer +- air_energy_recovery +- temperature_control +- operation_during_occupied +- operation_during_unoccupied +- fan_control (cp) +- reset_differential_temperature +- supply_air_temperature_reset_load_fraction +- fan_volume_reset_type +- fan_volume_reset_fraction +- minimum_airflow +- minimum_outdoor_airflow +- maximum_outdoor_airflow +- demand_control_ventilation_control + +AirEconomizer +- type +- high_limit_shutoff_temperature + +AirEnergyRecovery +- enthalpy_recovery_ratio +- energy_recovery_operation (cp) + +FanOutputValidationPoint +- airflow +- result + +Terminal (probably should do early since critical) +- type +- served_by_heating_ventilating_air_conditioning_system +- heating_source +- heating_from_loop +- cooling_source +- cooling_from_loop +- fan +- fan_configuration +- primary_airflow +- supply_design_heating_setpoint_temperature +- supply_design_cooling_setpoint_temperature +- minimum_airflow +- minimum_outdoor_airflow +- minimum_outdoor_airflow_multiplier_schedule +- heating_capacity +- is_supply_ducted (cp) +- has_demand_control_ventilation + +FluidLoop +- type +- pump_power_per_flow_rate +- child_loops +- cooling_or_condensing_design_and_control +- heating_design_and_control + +FluidLoopDesignAndControl +- design_supply_temperature +- design_return_temperature +- is_sized_using_coincident_load +- minimum_flow_fraction +- operation +- operation_schedule +- flow_control +- temperature_reset_type +- outdoor_high_for_loop_supply_reset_temperature +- outdoor_low_for_loop_supply_reset_temperature +- loop_supply_temperature_at_outdoor_high +- loop_supply_temperature_at_outdoor_low +- loop_supply_temperature_at_low_load +- has_integrated_waterside_economizer + +Boiler +- draft_type (cp) +- operation_lower_limit +- operation_upper_limit + +Chiller +- compressor_type (cp) +- is_chilled_water_pump_interlocked +- is_condenser_water_pump_interlocked + +HeatRejection +- type +- fan_shaft_power (cp) +- fan_speed_control +- rated_water_flowrate (cp) +- leaving_water_setpoint_temperature + +ExternalFluidSource +- loop +- type + +OutputInstance: +- ruleset_model_type +- rotation_angle +- unmet_load_hours +- unmet_load_hours_heating +- unmet_occupied_load_hours_heating +- unmet_load_hours_cooling +- unmet_occupied_load_hours_cooling +- building_peak_cooling_load + + +Some remaining non-HVAC related items that may be added include: + +Building +- building_open_schedule +- measured_infiltration_pressure_difference + +BuildingSegment +- is_all_new (cp) +- area_type_vertical_fenestration (cp) +- lighting_building_area_type (cp) +- area_type_heating_ventilating_air_conditioning_system (cp) + +Zone: +- floor_name (cp) +- design_thermostat_cooling_setpoint +- design_thermostat_heating_setpoint +- maximum_humidity_setpoint_schedule +- zonal_exhaust_fan +- non_mechanical_cooling_fan_airflow (cp) +- air_distribution_effectiveness + +Space: +- occupant_sensible_heat_gain +- occupant_latent_heat_gain +- status_type (cp) +- function (cp) + +Infiltration: +- measured_air_leakage_rate (cp) + +Construction +- c_factor (cp) +- f_factor (cp) + +SurfaceOpticalProperties: +- absorptance_thermal_exterior +- absorptance_solar_exterior + +Subsurface: +- classification (cp) +- subclassification (cp) +- dynamic_glazing_type +- has_shading_overhang +- has_shading_sidefins +- has_manual_interior_shades (cp) + +InteriorLighting +- occupancy_control_type (cp) + +MiscellaneousEquipment +- type (cp) + +Transformer +- type (cp) +- phase +- efficiency +- capacity + +Schedule +- hourly_heating_design_day +- hourly_cooling_design_day +- type + +Weather +- ground_temperature_schedule +- data_source_type (cp) + +ExteriorLighting +- multiplier_schedule + + +(cp) indicates that it may need to be compliance parameter not based on simulation inputs or outputs + +This list is based on two sources: +- baseline_model.json +- docs\data_elements_used.yaml + +The baseline_model.json file is from https://github.com/pnnl/ruleset-checking-tool/blob/develop/examples/chicago_demo/baseline_model.json + +The data_elements_used.yaml file was generated by script from the files related to the PNNL Ruleset Checking +Tool in /ruletest_engine/ruletest_jsons/ashrae9012019 + + +## Outputs Description ## + +The new output file is a JSON file following the schema described here: + +https://github.com/open229/ruleset-model-description-schema + +## Engineering Reference ## + +No changes + +## Example File and Transition Changes ## + +None required. + +## Design Document ## + +In general, to try to maximize the number of new data elements implemented during this phase, items should be added based +on complexity. + +For EnergyPlus changes, add new columns in the following order based on difficulty: +1. Existing tables where new output is simple echo of input or already computed and in data structure +2. New tables where new output is simple echo of input or already computed and in data structure +3. New or existing tables where new output is easy to determine +4. More complicated outputs + +Echos of input are indicated in the eptags schema file. + +Provide draft updated output from EnergyPlus for OpenStudio team to test prior to release. + +For the createRulesetModelDecription Python script, will continue being developed using the same approach +as the 2022 adn 2023 work and will continue to include unit tests. This includes: + + - The Python utility is separate from EnergyPlus and will eventually be packaged with the EnergyPlus installer. It will + continue to be developed in its own repository but eventually this may be merged or linked from the EnergyPlus repository. + + - The Python utility reads the JSON files that EnergyPlus produces when the output:JSON input object is used as the primary + source of information. As a secondary source of information, the epJSON input is read. + + - The Ruleset Model Description (RMD) format will be produced by the utility and is also a JSON format. + + - Verification that the RMD output produced by the new utility is consistent with the RMD schema is performed by using + the jsonschema Python library "validate" method. + + - The PathLib library is used for accessing files. + + - The unittest library is used for providing unit testing. The goal is to have tests for almost all of the methods. + + - Only a subset of data groups from the RMD schema will be generated and only data elements that are most direct will be + implemented. This is expected to be the first step in an ongoing effort to fully implement the RMD schema as an output format. + +## References ## + +The original NFP is here: + +https://github.com/NREL/EnergyPlus/blob/develop/design/FY2022/NFP-InitialRulesetModelDescription.md + +The 2023 NFP is here: + +https://github.com/NREL/EnergyPlus/blob/develop/design/FY2023/NFP-RulesetModelDescriptionPhase2.md + +The repo for the script development is here: + +https://github.com/JasonGlazer/createRulesetModelDescription + +Some lessons learned from the initial effort in 2022 are described here: + +https://github.com/JasonGlazer/createRulesetModelDescription/blob/main/docs/lessons_learned.rst + +The schema is described here: + +https://github.com/open229/ruleset-model-description-schema/blob/main/schema-source/ASHRAE229_extra.schema.yaml From 35ad2991146b4f089267e5b0fa10d8dddb3e1c33 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 25 Jan 2024 11:01:11 -0600 Subject: [PATCH 003/115] for NFP added cross referencing in createRMD Enhancements section and other fixes [decent_ci_skip] [actions skip] --- .../NFP-RulesetModelDescriptionPhase3.md | 233 ++++++++++-------- 1 file changed, 131 insertions(+), 102 deletions(-) diff --git a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md index 2ff6d9ff2e0..b79645c1945 100644 --- a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md +++ b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md @@ -4,6 +4,7 @@ Ruleset Model Description Phase 3 **Jason Glazer, GARD Analytics** - January 18, 2024 + - January 25, 2024 - added cross referencing in createRMD Enhancements section and other fixes ## Justification for New Feature ## @@ -281,6 +282,20 @@ The current columns are (need to verify that these are populated): - Exhaust airflow - Outdoor airflow +#### Component Sizing Summary - PlantLoop #### + +The current columns are: +- Initial Maximum Loop Flow Rate [m3/s] +- Initial Plant Loop Volume [m3] +- Maximum Loop Flow Rate [m3/s] +- Plant Loop Volume [m3] + +The new columns would be: +- Design supply temperature +- Design return temperature +- Sizing option (Coincident/NonCoincident) +- Minimum Loop Flow Rate [m3/s] + ### Add New EnergyPlus Tabular Reports and Tables ### @@ -339,7 +354,8 @@ with control options and identifies the type, where they apply, sense, and contr - minimum and maximum setpoint temperatures - minimum turndown ratio - schedules -- load ranges +- load range lower limit +- load range upper limit - Setpoint at Outdoor Low Temperature - Outdoor Low Temperature - Setpoint at Outdoor High Temperature @@ -351,6 +367,12 @@ available within the data structure that would be useful to report. Include spec - Heat Recovery - Operation With Economizer - Heat Recovery - Supply Air Temperature Control +- Setpoint Managers - FanSystem - temperature_control +- Setpoint Managers - FanSystem - reset_differential_temperature +- Setpoint Managers - FanSystem - supply_air_temperature_reset_load_fraction +- AvailabilityManager:Scheduled +- Pump and fan availability schedules +- Setpoint Managers - FluidLoopDesignAndControl - temperature_reset_type ## Testing/Validation/Data Sources ## @@ -370,124 +392,134 @@ Additional tabular outputs will be described in the IOref. ## createRMD Enhancements ### -Certain data groups and elements are more important to implement since they are used by PNNL's Ruleset Checking Tool: +The following describes the new data elements and data groups that will be added to createRMD. These are based on +what is needed since they are used by PNNL's Ruleset Checking Tool. Note that not all data elements will be +supported that are shown below. Data elements followed by (cp) are compliance parameters and are not able to be +captured in input to, or output from, EnergyPlus. In addition, data elements followed by (nc) have no corresponding +data column from EnergyPlus output and no plans to support that data element. These are typically only available +as input or would be complicated to support as output. After other data elements in parenthesis is the EnergyPlus +report that can be used to populate that data element. + +^means that it is in in schema.yaml and column is defined-delete after assessment HeatingVentilatingAirConditioningSystem -- preheat_system +- preheat_system (topology report) CoolingSystem: -- dehumidification_type +- dehumidification_type (topology report) FanSystem: -- return_fans -- exhaust_fans -- relief_fans -- air_economizer -- air_energy_recovery -- temperature_control -- operation_during_occupied -- operation_during_unoccupied +- return_fans (PROBABLY topology report) +- exhaust_fans (Component Sizing Summary AND topology report) +- relief_fans (PROBABLY topology report) +- air_economizer (System Summary - Economizer) +- air_energy_recovery (Component Sizing Summary) +- temperature_control (Controls report) +- operation_during_occupied (Equipment Summary - Fans) +- operation_during_unoccupied (Equipment Summary - Fans) - fan_control (cp) -- reset_differential_temperature -- supply_air_temperature_reset_load_fraction -- fan_volume_reset_type -- fan_volume_reset_fraction -- minimum_airflow -- minimum_outdoor_airflow -- maximum_outdoor_airflow -- demand_control_ventilation_control +- reset_differential_temperature (Controls report) +- supply_air_temperature_reset_load_fraction (Controls report) +- fan_volume_reset_type (nc) +- fan_volume_reset_fraction (nc) +- minimum_airflow (Standard 62.1 Summary) +- minimum_outdoor_airflow (Component Sizing Summary) +- maximum_outdoor_airflow (Component Sizing Summary) +- demand_control_ventilation_control (System Summary - Demand Controlled Ventilation using Controller:MechanicalVentilation - Type) AirEconomizer -- type -- high_limit_shutoff_temperature +- type (System Summary - Economizer) +- high_limit_shutoff_temperature (System Summary - Economizer) AirEnergyRecovery -- enthalpy_recovery_ratio +- enthalpy_recovery_ratio (cp) - energy_recovery_operation (cp) FanOutputValidationPoint -- airflow -- result +- airflow (nc) +- result (nc) Terminal (probably should do early since critical) -- type -- served_by_heating_ventilating_air_conditioning_system -- heating_source -- heating_from_loop -- cooling_source -- cooling_from_loop -- fan -- fan_configuration -- primary_airflow -- supply_design_heating_setpoint_temperature -- supply_design_cooling_setpoint_temperature -- minimum_airflow -- minimum_outdoor_airflow -- minimum_outdoor_airflow_multiplier_schedule -- heating_capacity +- type (Equipment Summary - AirTerminals - type) +- served_by_heating_ventilating_air_conditioning_system (topology report) +- heating_source (Equipment Summary - AirTerminals - Heat/Reheat Coil Object Type) +- heating_from_loop (Equipment Summary - AirTerminals - Hot Water Plant Loop Name) +- cooling_source (Equipment Summary - AirTerminals, Chilled Water Coil Object Type) +- cooling_from_loop (Equipment Summary - AirTerminals, Chilled Water Plant Loop Name) +- fan (Equipment Summary - AirTerminals, Fan Name) +- fan_configuration (Equipment Summary - AirTerminals, type of input object) +- primary_airflow (Equipment Summary - AirTerminals, Primary Air Flow Rate) +- supply_design_heating_setpoint_temperature (Equipment Summary - AirTerminals, Supply heating setpoint) +- supply_design_cooling_setpoint_temperature (Equipment Summary - AirTerminals, Supply cooling setpoint) +- minimum_airflow (Standard 62.1 Summary) +- minimum_outdoor_airflow (Standard 62.1 Summary) +- minimum_outdoor_airflow_multiplier_schedule (Equipment Summary - AirTerminals, Minimum Flow Schedule Name) +- heating_capacity (Equipment Summary - AirTerminals, heating capacity) - is_supply_ducted (cp) -- has_demand_control_ventilation +- has_demand_control_ventilation (System Summary - Demand Controlled Ventilation using Controller:MechanicalVentilation, Controller:MechanicalVentilation Name, Demand Controlled Ventilation) FluidLoop -- type -- pump_power_per_flow_rate -- child_loops -- cooling_or_condensing_design_and_control -- heating_design_and_control +- type (Equipment Summary - PlantLoop or CondenserLoop) +- pump_power_per_flow_rate (Equipment Summary - PlantLoop or CondenserLoop, Total pump power on loop) +- child_loops (topology report) +- cooling_or_condensing_design_and_control (Equipment Summary - PlantLoop or CondenserLoop) +- heating_design_and_control (Equipment Summary - PlantLoop or CondenserLoop) FluidLoopDesignAndControl -- design_supply_temperature -- design_return_temperature -- is_sized_using_coincident_load -- minimum_flow_fraction -- operation -- operation_schedule -- flow_control -- temperature_reset_type -- outdoor_high_for_loop_supply_reset_temperature -- outdoor_low_for_loop_supply_reset_temperature -- loop_supply_temperature_at_outdoor_high -- loop_supply_temperature_at_outdoor_low -- loop_supply_temperature_at_low_load -- has_integrated_waterside_economizer +- design_supply_temperature (Component Sizing Summary - PlantLoop, Design supply temperature) +- design_return_temperature (Component Sizing Summary - PlantLoop, Design return temperature) +- is_sized_using_coincident_load (Component Sizing Summary - PlantLoop, Sizing option) +- minimum_flow_fraction (Component Sizing Summary - PlantLoop, Minimum Loop Flow Rate) +- operation (Equipment Summary - Pumps, Control) +- operation_schedule (Controls) +- flow_control (Equipment Summary - Pumps, Type) +- temperature_reset_type (Controls) +- outdoor_high_for_loop_supply_reset_temperature (Controls) +- outdoor_low_for_loop_supply_reset_temperature (Controls) +- loop_supply_temperature_at_outdoor_high (Controls) +- loop_supply_temperature_at_outdoor_low (Controls) +- loop_supply_temperature_at_low_load (Controls) +- has_integrated_waterside_economizer (topology) Boiler - draft_type (cp) -- operation_lower_limit -- operation_upper_limit +- operation_lower_limit (Controls) +- operation_upper_limit (Controls) Chiller - compressor_type (cp) -- is_chilled_water_pump_interlocked -- is_condenser_water_pump_interlocked +- is_chilled_water_pump_interlocked (topology) +- is_condenser_water_pump_interlocked (topology) HeatRejection -- type +- type (Equipment Summary - Cooling Towers and Fluid Coolers, type) - fan_shaft_power (cp) -- fan_speed_control +- fan_speed_control (Equipment Summary - Cooling Towers and Fluid Coolers, type) - rated_water_flowrate (cp) -- leaving_water_setpoint_temperature +- leaving_water_setpoint_temperature (Equipment Summary - Cooling Towers and Fluid Coolers, Leaving Water Setpoint Temperature) ExternalFluidSource -- loop -- type +- loop (topology) +- type (topology) OutputInstance: -- ruleset_model_type -- rotation_angle -- unmet_load_hours -- unmet_load_hours_heating -- unmet_occupied_load_hours_heating -- unmet_load_hours_cooling -- unmet_occupied_load_hours_cooling -- building_peak_cooling_load +- ruleset_model_type (cp) +- rotation_angle (cp, could be from Compliance:Building) +- unmet_load_hours (system summary) +- unmet_load_hours_heating (system summary) +- unmet_occupied_load_hours_heating (system summary) +- unmet_load_hours_cooling (system summary) +- unmet_occupied_load_hours_cooling (system summary) +- building_peak_cooling_load (HVAC Sizing Summary) Some remaining non-HVAC related items that may be added include: +RulesetModelDescription +- measured_infiltration_pressure_difference (cp) + Building -- building_open_schedule -- measured_infiltration_pressure_difference +- building_open_schedule (cp) BuildingSegment - is_all_new (cp) @@ -497,16 +529,16 @@ BuildingSegment Zone: - floor_name (cp) -- design_thermostat_cooling_setpoint -- design_thermostat_heating_setpoint -- maximum_humidity_setpoint_schedule -- zonal_exhaust_fan +- design_thermostat_cooling_setpoint (nc) +- design_thermostat_heating_setpoint (nc) +- maximum_humidity_setpoint_schedule (nc) +- zonal_exhaust_fan (nc) - non_mechanical_cooling_fan_airflow (cp) -- air_distribution_effectiveness +- air_distribution_effectiveness (nc) Space: -- occupant_sensible_heat_gain -- occupant_latent_heat_gain +- occupant_sensible_heat_gain (nc) +- occupant_latent_heat_gain (nc) - status_type (cp) - function (cp) @@ -518,15 +550,15 @@ Construction - f_factor (cp) SurfaceOpticalProperties: -- absorptance_thermal_exterior -- absorptance_solar_exterior +- absorptance_thermal_exterior (nc) +- absorptance_solar_exterior (nc) Subsurface: - classification (cp) - subclassification (cp) -- dynamic_glazing_type -- has_shading_overhang -- has_shading_sidefins +- dynamic_glazing_type (nc) +- has_shading_overhang (nc) +- has_shading_sidefins (nc) - has_manual_interior_shades (cp) InteriorLighting @@ -537,24 +569,21 @@ MiscellaneousEquipment Transformer - type (cp) -- phase -- efficiency -- capacity +- phase (nc) +- efficiency (nc) +- capacity (nc) Schedule -- hourly_heating_design_day -- hourly_cooling_design_day -- type +- hourly_heating_design_day (nc) +- hourly_cooling_design_day (nc) +- type (nc) Weather -- ground_temperature_schedule +- ground_temperature_schedule (nc) - data_source_type (cp) -ExteriorLighting -- multiplier_schedule - - (cp) indicates that it may need to be compliance parameter not based on simulation inputs or outputs +(nc) indicates that no corresponding data column exists and we have no plans to support that data element This list is based on two sources: - baseline_model.json From cf72a0635e8240abe371f106d4c3bd3c349bca5f Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 26 Jan 2024 15:08:01 -0600 Subject: [PATCH 004/115] Rough in HVAC topology report --- src/EnergyPlus/OutputReportPredefined.cc | 36 +++++++++++++++++++++++ src/EnergyPlus/OutputReportPredefined.hh | 37 ++++++++++++++++++++++++ 2 files changed, 73 insertions(+) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index f16f54edba1..6e2257f6d67 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -891,6 +891,42 @@ namespace OutputReportPredefined { s->pdchULnotMetHeatOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Heating [hr]"); s->pdchULnotMetCoolOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Cooling [hr]"); + // HVAC Topology Report + s->pdrTopology = newPreDefReport(state, "HVACTopology", "Top", "HVAC Topology"); + + s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Component Arrangement"); + s->pdchTopAirSide = newPreDefColumn(state, s->pdstTopAirLoop, "Side"); + s->pdchTopAirParType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Type"); + s->pdchTopAirParName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Name"); + s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); + s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); + s->pdchTopAirConType= newPreDefColumn(state, s->pdstTopAirLoop, "Connection Type"); + + s->pdstTopZnEqpLoop = newPreDefSubTable(state, s->pdrTopology, " Zone Equipment Component Arrangement"); + s->pdchTopZnEqpSide = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Side"); + s->pdchTopZnEqpParType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Parent Type"); + s->pdchTopZnEqpParName = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Parent Name"); + s->pdchTopZnEqpCompType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Component Type"); + s->pdchTopZnEqpCompName = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Component Name"); + s->pdchTopZnEqpConType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Connection Type"); + + s->pdstTopPlantLoop = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement"); + s->pdchTopPlantSide = newPreDefColumn(state, s->pdstTopPlantLoop, "Side"); + s->pdchTopPlantParType = newPreDefColumn(state, s->pdstTopPlantLoop, "Parent Type"); + s->pdchTopPlantParName = newPreDefColumn(state, s->pdstTopPlantLoop, "Parent Name"); + s->pdchTopPlantCompType = newPreDefColumn(state, s->pdstTopPlantLoop, "Component Type"); + s->pdchTopPlantCompName = newPreDefColumn(state, s->pdstTopPlantLoop, "Component Name"); + s->pdchTopPlantConType = newPreDefColumn(state, s->pdstTopPlantLoop, "Connection Type"); + + s->pdstTopCondLoop = newPreDefSubTable(state, s->pdrTopology, "Condenser Loop Component Arrangement"); + s->pdchTopCondSide = newPreDefColumn(state, s->pdstTopCondLoop, "Side"); + s->pdchTopCondParType = newPreDefColumn(state, s->pdstTopCondLoop, "Parent Type"); + s->pdchTopCondParName = newPreDefColumn(state, s->pdstTopCondLoop, "Parent Name"); + s->pdchTopCondCompType = newPreDefColumn(state, s->pdstTopCondLoop, "Component Type"); + s->pdchTopCondCompName = newPreDefColumn(state, s->pdstTopCondLoop, "Component Name"); + s->pdchTopCondConType = newPreDefColumn(state, s->pdstTopCondLoop, "Connection Type"); + + // Outdoor Air Report s->pdrOutsideAir = newPreDefReport(state, "OutdoorAirSummary", "OA", "Outdoor Air Summary"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index df7f4869b0f..6620c2af2b7 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -864,6 +864,43 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchULnotMetHeatOcc = 0; int pdchULnotMetCoolOcc = 0; + // HVAC Topology + int pdrTopology = 0; + + int pdstTopAirLoop = 0; + int pdchTopAirSide = 0; + int pdchTopAirParType = 0; + int pdchTopAirParName = 0; + int pdchTopAirCompType = 0; + int pdchTopAirCompName = 0; + int pdchTopAirConType = 0; + + int pdstTopZnEqpLoop = 0; + int pdchTopZnEqpSide = 0; + int pdchTopZnEqpParType = 0; + int pdchTopZnEqpParName = 0; + int pdchTopZnEqpCompType = 0; + int pdchTopZnEqpCompName = 0; + int pdchTopZnEqpConType = 0; + + int pdstTopPlantLoop = 0; + int pdchTopPlantSide = 0; + int pdchTopPlantParType = 0; + int pdchTopPlantParName = 0; + int pdchTopPlantCompType = 0; + int pdchTopPlantCompName = 0; + int pdchTopPlantConType = 0; + + int pdstTopCondLoop = 0; + int pdchTopCondSide = 0; + int pdchTopCondParType = 0; + int pdchTopCondParName = 0; + int pdchTopCondCompType = 0; + int pdchTopCondCompName = 0; + int pdchTopCondConType = 0; + + + // Outdoor Air Report int pdrOutsideAir = 0; int pdstOAavgOcc = 0; From 5d4980b2fe07c2002e1a7f68d28f135af19a071b Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 30 Jan 2024 13:57:28 -0600 Subject: [PATCH 005/115] Add new predefined report columns --- .../NFP-RulesetModelDescriptionPhase3.md | 2 +- src/EnergyPlus/OutputReportPredefined.cc | 24 ++++++++++++++++--- src/EnergyPlus/OutputReportPredefined.hh | 22 ++++++++++++++--- 3 files changed, 41 insertions(+), 7 deletions(-) diff --git a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md index b79645c1945..48c2c339939 100644 --- a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md +++ b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md @@ -146,7 +146,6 @@ The current columns are: The new columns would be: - Airloop branch name - Plantloop branch name -- Supplemental heat high shutoff temperature [C] #### Equipment Summary - DX Heating Coils #### @@ -160,6 +159,7 @@ The current columns are: - Airloop name The new columns would be: +- Supplemental heat high shutoff temperature [C] - Airloop branch name #### Equipment Summary - Fans #### diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 6e2257f6d67..099d955bbfa 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -389,6 +389,7 @@ namespace OutputReportPredefined { // Std 229 Predef outputs for DX Heating Coils s->pdchDXHeatCoilMinOADBTforCompOp = newPreDefColumn(state, s->pdstDXHeatCoil, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation"); + s->pdchDXHeatCoilSuppHiT = newPreDefColumn(state, s->pdstDXHeatCoil, "Supplemental Heat High Shutoff Temperature [C]"); s->pdchDXHeatCoilAirloopName = newPreDefColumn(state, s->pdstDXHeatCoil, "Airloop Name"); // for DX Heating Coil AHRI Standard 2023 Ratings | HSPF2 @@ -428,6 +429,10 @@ namespace OutputReportPredefined { s->pdchFanAutosized = newPreDefColumn(state, s->pdstFan, "Is Autosized"); s->pdchFanMotorEff = newPreDefColumn(state, s->pdstFan, "Motor Efficiency"); s->pdchFanMotorHeatToZoneFrac = newPreDefColumn(state, s->pdstFan, "Motor Heat to Zone Fraction"); + s->pdchFanMotorHeatZone = newPreDefColumn(state, s->pdstFan, "Motor Loss Zone Name"); + s->pdchFanOccOper = newPreDefColumn(state, s->pdstFan, "Occupied Operation"); + s->pdchFanUnoccOper = newPreDefColumn(state, s->pdstFan, "Unoccupied Operation"); + s->pdchFanLockOutDurCentHt = newPreDefColumn(state, s->pdstFan, "Locked Out During Central Heating"); s->pdchFanAirLoopName = newPreDefColumn(state, s->pdstFan, "Airloop Name"); s->pdstPump = newPreDefSubTable(state, s->pdrEquip, "Pumps"); @@ -514,6 +519,7 @@ namespace OutputReportPredefined { s->pdchPLCLProvCool = newPreDefColumn(state, s->pdstPLCL, "Provides Cooling"); s->pdchPLCLMaxLoopFlowRate = newPreDefColumn(state, s->pdstPLCL, "Maximum Loop Flow Rate [m3/s]"); s->pdchPLCLMinLoopFlowRate = newPreDefColumn(state, s->pdstPLCL, "Minimum Loop Flow Rate [m3/s]"); + s->pdchPLCLTotPumpPow = newPreDefColumn(state, s->pdstPLCL, "Total Pump Power on Loop [W]"); // Std 229 Air Terminal Table in Equipment Summary s->pdstAirTerm = newPreDefSubTable(state, s->pdrEquip, "Air Terminals"); @@ -526,6 +532,18 @@ namespace OutputReportPredefined { s->pdchAirTermHeatingCap = newPreDefColumn(state, s->pdstAirTerm, "Heating Capacity [W]"); s->pdchAirTermCoolingCap = newPreDefColumn(state, s->pdstAirTerm, "Cooling Capacity [W]"); + s->pdchAirTermTypeInp = newPreDefColumn(state, s->pdstAirTerm, "Type of Input Object"); + s->pdchAirTermHeatCoilType = newPreDefColumn(state, s->pdstAirTerm, "Heat/Reheat Coil Object Type"); + s->pdchAirTermCoolCoilType = newPreDefColumn(state, s->pdstAirTerm, "Chilled Water Coil Object Type"); + s->pdchAirTermFanType = newPreDefColumn(state, s->pdstAirTerm, "Fan Object Type"); + s->pdchAirTermFanName = newPreDefColumn(state, s->pdstAirTerm, "Fan Name"); + s->pdchAirTermPrimFlow = newPreDefColumn(state, s->pdstAirTerm, "Primary Air Flow Rate [m3/s]"); + s->pdchAirTermSecdFlow = newPreDefColumn(state, s->pdstAirTerm, "Secondary Air Flow Rate [m3/s]"); + s->pdchAirTermMinFlowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow Schedule Name"); + s->pdchAirTermMaxFlowReh = newPreDefColumn(state, s->pdstAirTerm, "Maximum Flow During Reheat [m3/s]"); + s->pdchAirTermMinOAflowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow Schedule Name"); + s->pdchAirTermTempCntl = newPreDefColumn(state, s->pdstAirTerm, "Temperature Control"); + // Std 229 Air Heat Recovery s->pdstAirHR = newPreDefSubTable(state, s->pdrEquip, "Air Heat Recovery"); @@ -879,6 +897,7 @@ namespace OutputReportPredefined { s->pdchDCVZoneADEffCooling = newPreDefColumn(state, s->pdstDemCntlVent, "Air Distribution Effectiveness in Cooling Mode"); s->pdchDCVZoneADEffHeating = newPreDefColumn(state, s->pdstDemCntlVent, "Air Distribution Effectiveness in Heating Mode"); s->pdchDCVZoneADEffSchName = newPreDefColumn(state, s->pdstDemCntlVent, "Air Distribution Effectiveness Schedule Name"); + s->pdchDCVType = newPreDefColumn(state, s->pdstDemCntlVent, "Type"); s->pdstSimpleComfort = newPreDefSubTable(state, s->pdrSystem, "Time Not Comfortable Based on Simple ASHRAE 55-2004"); s->pdchSCwinterClothes = newPreDefColumn(state, s->pdstSimpleComfort, "Winter Clothes [hr]"); @@ -891,7 +910,7 @@ namespace OutputReportPredefined { s->pdchULnotMetHeatOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Heating [hr]"); s->pdchULnotMetCoolOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Cooling [hr]"); - // HVAC Topology Report + // HVAC Topology Report s->pdrTopology = newPreDefReport(state, "HVACTopology", "Top", "HVAC Topology"); s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Component Arrangement"); @@ -900,7 +919,7 @@ namespace OutputReportPredefined { s->pdchTopAirParName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Name"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); - s->pdchTopAirConType= newPreDefColumn(state, s->pdstTopAirLoop, "Connection Type"); + s->pdchTopAirConType = newPreDefColumn(state, s->pdstTopAirLoop, "Connection Type"); s->pdstTopZnEqpLoop = newPreDefSubTable(state, s->pdrTopology, " Zone Equipment Component Arrangement"); s->pdchTopZnEqpSide = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Side"); @@ -926,7 +945,6 @@ namespace OutputReportPredefined { s->pdchTopCondCompName = newPreDefColumn(state, s->pdstTopCondLoop, "Component Name"); s->pdchTopCondConType = newPreDefColumn(state, s->pdstTopCondLoop, "Connection Type"); - // Outdoor Air Report s->pdrOutsideAir = newPreDefReport(state, "OutdoorAirSummary", "OA", "Outdoor Air Summary"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 6620c2af2b7..479a0e00a3d 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -246,7 +246,11 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchFanPurpose = 0; int pdchFanAutosized = 0; int pdchFanMotorEff = 0; - int pdchFanMotorHeatToZoneFrac = 0; + int pdchFanMotorHeatToZoneFrac = 0; // Motor Heat to Zone Fraction + int pdchFanMotorHeatZone = 0; // Motor Loss Zone Name + int pdchFanOccOper = 0; // Occupied Operation + int pdchFanUnoccOper = 0; // Unoccupied Operation + int pdchFanLockOutDurCentHt = 0; // Locked Out During Central Heating int pdchFanAirLoopName = 0; // Pump subtable @@ -349,6 +353,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchDXHeatCoilRegionNum = 0; // Region number for which HSPF is calculated // Standard 229 Predef outputs for DX Heating Coils int pdchDXHeatCoilMinOADBTforCompOp = 0; + int pdchDXHeatCoilSuppHiT = 0; // Supplemental Heat High Shutoff Temperature int pdchDXHeatCoilAirloopName = 0; // DX Heating Coil subtable| AHRI std. 210/240 2023 conditions @@ -438,6 +443,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchPLCLProvCool = 0; // provides cooling int pdchPLCLMaxLoopFlowRate = 0; // Maximum Loop Flow Rate int pdchPLCLMinLoopFlowRate = 0; // Minimum Loop Flow Rate + int pdchPLCLTotPumpPow = 0; // Total Pump Power on Loop // Std 229 Air Terminal Table in Equipment Summary int pdstAirTerm = 0; @@ -448,6 +454,17 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchAirTermSupHeatingSP = 0; // Supply heating setpoint int pdchAirTermHeatingCap = 0; // Heating capacity int pdchAirTermCoolingCap = 0; // Cooling capacity + int pdchAirTermTypeInp = 0; // Type of Input Object + int pdchAirTermHeatCoilType = 0; // Heat/Reheat Coil Object Type + int pdchAirTermCoolCoilType = 0; // Chilled Water Coil Object Type + int pdchAirTermFanType = 0; // Fan Object Type + int pdchAirTermFanName = 0; // Fan Name + int pdchAirTermPrimFlow = 0; // Primary Air Flow Rate + int pdchAirTermSecdFlow = 0; // Secondary Air Flow Rate + int pdchAirTermMinFlowSch = 0; // Minimum Flow Schedule Name + int pdchAirTermMaxFlowReh = 0; // Maximum Flow During Reheat + int pdchAirTermMinOAflowSch = 0; // Minimum Outdoor Flow Schedule Name + int pdchAirTermTempCntl = 0; // Temperature Control // Std 229 Air Heat Recovery int pdstAirHR = 0; @@ -853,6 +870,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchDCVZoneADEffCooling = 0; int pdchDCVZoneADEffHeating = 0; int pdchDCVZoneADEffSchName = 0; + int pdchDCVType = 0; int pdstSimpleComfort = 0; int pdchSCwinterClothes = 0; @@ -899,8 +917,6 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopCondCompName = 0; int pdchTopCondConType = 0; - - // Outdoor Air Report int pdrOutsideAir = 0; int pdstOAavgOcc = 0; From f62c567b74f628e936582a212a4e8bc1c3e5387d Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 2 Feb 2024 10:12:25 -0600 Subject: [PATCH 006/115] Add section in NFP on handling compliance parameters [decent_ci_skip] [actions skip] --- .../NFP-RulesetModelDescriptionPhase3.md | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md index 48c2c339939..7d803788555 100644 --- a/design/FY2024/NFP-RulesetModelDescriptionPhase3.md +++ b/design/FY2024/NFP-RulesetModelDescriptionPhase3.md @@ -5,6 +5,7 @@ Ruleset Model Description Phase 3 - January 18, 2024 - January 25, 2024 - added cross referencing in createRMD Enhancements section and other fixes + - February 2, 2024 - added section on handling compliance parameters ## Justification for New Feature ## @@ -594,6 +595,46 @@ The baseline_model.json file is from https://github.com/pnnl/ruleset-checking-to The data_elements_used.yaml file was generated by script from the files related to the PNNL Ruleset Checking Tool in /ruletest_engine/ruletest_jsons/ashrae9012019 +## Handling Compliance Parameters ## + +Compliance parameters are those that cannot be determined by the simulation input or output and instead need to be +provided by the modeler as they are interpreting the design. These parameters should be organized so they can be +merged into the RMD file that is produced by the script. + +Options for compliance parameters: + +1. Add new fields to existing input objects associated with them and create or add to tabular report that echos +them out +2. Add new fields to existing input objects associated with them and parse the epJSON files to get them +3. Add new Compliance input objects like existing Compliance:Building and report them in tabular reports +4. Add new Compliance input objects like existing Compliance:Building and parse the epJSON to get them (essentially +ignore these inputs by EnergyPlus like HVACTemplate objects are ignored). A preprocessor would need to delete them. +5. Add new generic tag object (https://github.com/NREL/EnergyPlus/issues/8775) to associate new key-value pairs for +compliance parameters and create a tabular report that echos them out +6. Create a JSON file that contains the compliance parameters but the layout would need to match the layout of the +RMD file so that it could be merged. Use createRMD to make an empty file to make it easier for user to populate +and would be different for each EnergyPlus input file. GUI developers would probably not need the created empty files. +7. Create a YAML file that contains the compliance parameters but the layout would need to match the layout of the +RMD file so that it could be merged. Use createRMD to make an empty file to make it easier for user to populate and +would be different for each EnergyPlus input file. GUI developers would probably not need the created empty files. +8. Create a JSON patch file (https://jsonpatch.com/) containing the compliance parameters and values. Use createRMD +to make an empty file to make it easier for user to populate and would be different for each EnergyPlus input file. +9. Create a separate IDD for the compliance parameters and users can create a special IDF that just contains them +that can be read. Keeping both files synchronized would be difficult. + +For many of these the factor of being able to use IDF Editor (or eventually the epJSON Editor) or simply add and +manipulate an IDF file using current workflows is important. For GUIs they would probably also prefer to simply +generate an IDF or epJSON file directly that contains everything since the GUI would also now need new entry +fields for users to populate. A GUI could also generate the JSON patch file directly. + +Options 1 to 5 are all keeping the information together in a single IDF or epJSON file and would probably be +easiest for the user or GUI developer. + +Options 6 to 8 may be easier to program but more difficult for users and developers. If no creation of empty +compliance parameter file is done, they are definitely the easiest approach. + +For now the recommendation is to use option 8. In the future, options 2 and 4 could be pursued and they could create +a JSON patch file as part of the preprocessor. Option 8 is the easiest option in the short term to implement. ## Outputs Description ## From 962541b44978857bdad0b6a75cc4e82840b7809a Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 12 Feb 2024 11:51:05 -0600 Subject: [PATCH 007/115] Trying to add fan motor heat zone --- src/EnergyPlus/HVACFan.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/EnergyPlus/HVACFan.cc b/src/EnergyPlus/HVACFan.cc index e9531024d4c..6fa76aadfa6 100644 --- a/src/EnergyPlus/HVACFan.cc +++ b/src/EnergyPlus/HVACFan.cc @@ -315,6 +315,9 @@ namespace HVACFan { state, state.dataOutRptPredefined->pdchFanAutosized, name, m_designAirVolFlowRateWasAutosized ? "Yes" : "No"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, name, m_motorEff); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, name, m_motorInAirFrac); +// if (m_heatLossesDestination == ThermalLossDestination::ZoneGains) { +// OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, name, state.dataHeatBal->Zone(m_zoneNum).Name); +// } OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, name, From abf9e6bb2b54d73d9d9a02c61b4caaa6820e598a Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 15 Feb 2024 15:25:17 -0600 Subject: [PATCH 008/115] Add heat to zone and zone name. --- src/EnergyPlus/Fans.cc | 3 ++- src/EnergyPlus/HVACFan.cc | 8 ++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/EnergyPlus/Fans.cc b/src/EnergyPlus/Fans.cc index 6c86e82c2af..a53d528cffe 100644 --- a/src/EnergyPlus/Fans.cc +++ b/src/EnergyPlus/Fans.cc @@ -1447,7 +1447,8 @@ void SizeFan(EnergyPlusData &state, int const FanNum) fan.FanName, fan.MaxAirFlowRateIsAutosizable ? "Yes" : "No"); // autosizable vs. autosized equivalent? OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, fan.FanName, fan.MotEff); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, fan.FanName, fan.MotInAirFrac); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, fan.FanName, 0.0); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, fan.FanName, "n/a"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, fan.FanName, diff --git a/src/EnergyPlus/HVACFan.cc b/src/EnergyPlus/HVACFan.cc index 6fa76aadfa6..5b8a028d137 100644 --- a/src/EnergyPlus/HVACFan.cc +++ b/src/EnergyPlus/HVACFan.cc @@ -314,10 +314,10 @@ namespace HVACFan { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchFanAutosized, name, m_designAirVolFlowRateWasAutosized ? "Yes" : "No"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, name, m_motorEff); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, name, m_motorInAirFrac); -// if (m_heatLossesDestination == ThermalLossDestination::ZoneGains) { -// OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, name, state.dataHeatBal->Zone(m_zoneNum).Name); -// } + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, name, 1- m_motorInAirFrac); + if (m_heatLossesDestination == ThermalLossDestination::ZoneGains) { + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, name, state.dataHeatBal->Zone(m_zoneNum).Name); + } OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, name, From ab9669cf6dbac0631b094a6b8577b073753187b3 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Thu, 15 Feb 2024 16:23:29 -0600 Subject: [PATCH 009/115] Initial HVAC Toplogy Reports --- src/EnergyPlus/DataZoneEquipment.cc | 8 +- src/EnergyPlus/OutputReportPredefined.cc | 64 ++++---- src/EnergyPlus/OutputReportPredefined.hh | 58 +++---- src/EnergyPlus/Plant/Loop.hh | 2 + src/EnergyPlus/Plant/PlantManager.cc | 190 +++++++++++++++++++---- src/EnergyPlus/Plant/PlantManager.hh | 30 +++- src/EnergyPlus/SystemReports.cc | 136 ++++++++++++++++ src/EnergyPlus/SystemReports.hh | 14 ++ 8 files changed, 414 insertions(+), 88 deletions(-) diff --git a/src/EnergyPlus/DataZoneEquipment.cc b/src/EnergyPlus/DataZoneEquipment.cc index a7652c1348a..f9152d21b45 100644 --- a/src/EnergyPlus/DataZoneEquipment.cc +++ b/src/EnergyPlus/DataZoneEquipment.cc @@ -264,13 +264,11 @@ void GetZoneEquipmentData(EnergyPlusData &state) state.dataZoneEquip->ReturnAirPath.allocate(state.dataZoneEquip->NumReturnAirPaths); } - state.dataZoneEquip->ZoneEquipConfig.allocate(state.dataGlobal->NumOfZones); // Allocate the array containing the configuration + state.dataZoneEquip->ZoneEquipConfig.allocate(state.dataGlobal->NumOfZones); // Allocate the array containing the configuration data for each zone if (state.dataHeatBal->doSpaceHeatBalanceSizing || state.dataHeatBal->doSpaceHeatBalanceSimulation) { - state.dataZoneEquip->spaceEquipConfig.allocate(state.dataGlobal->numSpaces); // Allocate the array containing the configuration + state.dataZoneEquip->spaceEquipConfig.allocate( + state.dataGlobal->numSpaces); // Allocate the array containing the configuration data for each space } - // data for each zone to the number of controlled zones - // found in the input file. This may or may not - // be the same as the number of zones in the building state.dataZoneEquip->ZoneEquipList.allocate(state.dataGlobal->NumOfZones); state.dataZoneEquip->ZoneEquipAvail.dimension(state.dataGlobal->NumOfZones, NoAction); state.dataZoneEquip->UniqueZoneEquipListNames.reserve(state.dataGlobal->NumOfZones); diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 099d955bbfa..d0db563aeff 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -913,37 +913,43 @@ namespace OutputReportPredefined { // HVAC Topology Report s->pdrTopology = newPreDefReport(state, "HVACTopology", "Top", "HVAC Topology"); - s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Component Arrangement"); - s->pdchTopAirSide = newPreDefColumn(state, s->pdstTopAirLoop, "Side"); - s->pdchTopAirParType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Type"); - s->pdchTopAirParName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Name"); + s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); + s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); + s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); - s->pdchTopAirConType = newPreDefColumn(state, s->pdstTopAirLoop, "Connection Type"); - - s->pdstTopZnEqpLoop = newPreDefSubTable(state, s->pdrTopology, " Zone Equipment Component Arrangement"); - s->pdchTopZnEqpSide = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Side"); - s->pdchTopZnEqpParType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Parent Type"); - s->pdchTopZnEqpParName = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Parent Name"); - s->pdchTopZnEqpCompType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Component Type"); - s->pdchTopZnEqpCompName = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Component Name"); - s->pdchTopZnEqpConType = newPreDefColumn(state, s->pdstTopZnEqpLoop, "Connection Type"); - - s->pdstTopPlantLoop = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement"); - s->pdchTopPlantSide = newPreDefColumn(state, s->pdstTopPlantLoop, "Side"); - s->pdchTopPlantParType = newPreDefColumn(state, s->pdstTopPlantLoop, "Parent Type"); - s->pdchTopPlantParName = newPreDefColumn(state, s->pdstTopPlantLoop, "Parent Name"); - s->pdchTopPlantCompType = newPreDefColumn(state, s->pdstTopPlantLoop, "Component Type"); - s->pdchTopPlantCompName = newPreDefColumn(state, s->pdstTopPlantLoop, "Component Name"); - s->pdchTopPlantConType = newPreDefColumn(state, s->pdstTopPlantLoop, "Connection Type"); - - s->pdstTopCondLoop = newPreDefSubTable(state, s->pdrTopology, "Condenser Loop Component Arrangement"); - s->pdchTopCondSide = newPreDefColumn(state, s->pdstTopCondLoop, "Side"); - s->pdchTopCondParType = newPreDefColumn(state, s->pdstTopCondLoop, "Parent Type"); - s->pdchTopCondParName = newPreDefColumn(state, s->pdstTopCondLoop, "Parent Name"); - s->pdchTopCondCompType = newPreDefColumn(state, s->pdstTopCondLoop, "Component Type"); - s->pdchTopCondCompName = newPreDefColumn(state, s->pdstTopCondLoop, "Component Name"); - s->pdchTopCondConType = newPreDefColumn(state, s->pdstTopCondLoop, "Connection Type"); + s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); + s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); + s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); + s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); + + s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); + s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); + s->pdchTopAirSupplyPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Type"); + s->pdchTopAirSupplyPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Name"); + s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); + s->pdchTopAirTermUnitType = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Type"); + s->pdchTopAirTermUnitName = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Name"); + s->pdchTopAirReturnPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Type"); + s->pdchTopAirReturnPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Name"); + + s->pdstTopZnEqp = newPreDefSubTable(state, s->pdrTopology, "Zone Equipment Component Arrangement"); + s->pdchTopZnEqpName = newPreDefColumn(state, s->pdstTopZnEqp, "Zone Name"); + s->pdchTopZnEqpCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Component Type"); + s->pdchTopZnEqpCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Component Name"); + s->pdchTopZnEqpSubCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Component Type"); + s->pdchTopZnEqpSubCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Component Name"); + s->pdchTopZnEqpSubSubCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Sub-Component Type"); + s->pdchTopZnEqpSubSubCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Sub-Component Name"); + + s->pdstTopPlantLoop2 = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement"); + s->pdchTopPlantLoopType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Type"); + s->pdchTopPlantLoopName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Name"); + s->pdchTopPlantSide2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Side"); + s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + s->pdchTopPlantBranchName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Branch Name"); + s->pdchTopPlantCompType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Type"); + s->pdchTopPlantCompName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Name"); // Outdoor Air Report s->pdrOutsideAir = newPreDefReport(state, "OutdoorAirSummary", "OA", "Outdoor Air Summary"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 479a0e00a3d..388bcd49efa 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -886,36 +886,42 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdrTopology = 0; int pdstTopAirLoop = 0; - int pdchTopAirSide = 0; - int pdchTopAirParType = 0; - int pdchTopAirParName = 0; + int pdchTopAirLoopName = 0; + int pdchTopAirBranchName = 0; int pdchTopAirCompType = 0; int pdchTopAirCompName = 0; - int pdchTopAirConType = 0; - - int pdstTopZnEqpLoop = 0; - int pdchTopZnEqpSide = 0; - int pdchTopZnEqpParType = 0; - int pdchTopZnEqpParName = 0; + int pdchTopAirSubCompType = 0; + int pdchTopAirSubCompName = 0; + int pdchTopAirSubSubCompType = 0; + int pdchTopAirSubSubCompName = 0; + + int pdstTopAirDemand = 0; + int pdchTopAirDemandName = 0; + int pdchTopAirSupplyPCompType = 0; + int pdchTopAirSupplyPCompName = 0; + int pdchTopAirZoneName = 0; + int pdchTopAirTermUnitType = 0; + int pdchTopAirTermUnitName = 0; + int pdchTopAirReturnPCompType = 0; + int pdchTopAirReturnPCompName = 0; + + int pdstTopZnEqp = 0; + int pdchTopZnEqpName = 0; int pdchTopZnEqpCompType = 0; int pdchTopZnEqpCompName = 0; - int pdchTopZnEqpConType = 0; - - int pdstTopPlantLoop = 0; - int pdchTopPlantSide = 0; - int pdchTopPlantParType = 0; - int pdchTopPlantParName = 0; - int pdchTopPlantCompType = 0; - int pdchTopPlantCompName = 0; - int pdchTopPlantConType = 0; - - int pdstTopCondLoop = 0; - int pdchTopCondSide = 0; - int pdchTopCondParType = 0; - int pdchTopCondParName = 0; - int pdchTopCondCompType = 0; - int pdchTopCondCompName = 0; - int pdchTopCondConType = 0; + int pdchTopZnEqpSubCompType = 0; + int pdchTopZnEqpSubCompName = 0; + int pdchTopZnEqpSubSubCompType = 0; + int pdchTopZnEqpSubSubCompName = 0; + + int pdstTopPlantLoop2 = 0; + int pdchTopPlantLoopType2 = 0; + int pdchTopPlantLoopName2 = 0; + int pdchTopPlantSide2 = 0; + int pdchTopPlantSplitMixName2 = 0; + int pdchTopPlantBranchName2 = 0; + int pdchTopPlantCompType2 = 0; + int pdchTopPlantCompName2 = 0; // Outdoor Air Report int pdrOutsideAir = 0; diff --git a/src/EnergyPlus/Plant/Loop.hh b/src/EnergyPlus/Plant/Loop.hh index 42f449607fb..f68b47e8ce1 100644 --- a/src/EnergyPlus/Plant/Loop.hh +++ b/src/EnergyPlus/Plant/Loop.hh @@ -68,6 +68,8 @@ namespace DataPlant { Num }; + constexpr std::array loopTypeNames = {"PlantLoop", "CondenserLoop", "Both"}; + struct HalfLoopContainer : std::array(DataPlant::LoopSideLocation::Num)> { HalfLoopData &operator()(LoopSideLocation ls) diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 7a841a988a3..d32bd8e48bb 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -1874,24 +1874,13 @@ void SetupReports(EnergyPlusData &state) // SUBROUTINE INFORMATION: // AUTHOR Rick Strand // DATE WRITTEN July 2001 - // MODIFIED na - // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: // This subroutine initializes the plant supply side reports. // It was created during the splitting of supply and demand side functions. - // Using/Aliasing - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - int LoopNum; // DO loop counter (plant supply sides) - int BranchNum; - int CompNum; - int MaxBranches; // Maximum number of branches on any plant loop (used for allocating arrays) - std::string CurrentModuleObject; // for ease in renaming. - int FluidIndex; + int MaxBranches = 0; // Maximum number of branches on any plant loop (used for allocating arrays) - MaxBranches = 0; for (auto &loop : state.dataPlnt->PlantLoop) { MaxBranches = max(MaxBranches, loop.LoopSide(LoopSideLocation::Demand).TotalBranches); MaxBranches = max(MaxBranches, loop.LoopSide(LoopSideLocation::Supply).TotalBranches); @@ -1907,14 +1896,8 @@ void SetupReports(EnergyPlusData &state) loop.OutletNodeFlowrate = 0.0; } - for (LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { + for (int LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { auto &loop = state.dataPlnt->PlantLoop(LoopNum); - if (LoopNum <= state.dataHVACGlobal->NumPlantLoops) { - CurrentModuleObject = "Plant Loop"; - } else { - CurrentModuleObject = "Cond Loop"; - } - // CurrentModuleObject='Plant/Condenser Loop' SetupOutputVariable(state, "Plant Supply Side Cooling Demand Rate", Constant::Units::W, @@ -1983,9 +1966,8 @@ void SetupReports(EnergyPlusData &state) } // setup more variables inside plant data structure - // CurrentModuleObject='Plant/Condenser Loop(Advanced)' if (state.dataGlobal->DisplayAdvancedReportVariables) { - for (LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { + for (int LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { SetupOutputVariable(state, "Plant Demand Side Lumped Capacitance Temperature", Constant::Units::C, @@ -2043,8 +2025,8 @@ void SetupReports(EnergyPlusData &state) OutputProcessor::SOVStoreType::Summed, state.dataPlnt->PlantLoop(LoopNum).Name); for (DataPlant::LoopSideLocation LoopSideNum : DataPlant::LoopSideKeys) { - for (BranchNum = 1; BranchNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).TotalBranches; ++BranchNum) { - for (CompNum = 1; CompNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).TotalComponents; + for (int BranchNum = 1; BranchNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).TotalBranches; ++BranchNum) { + for (int CompNum = 1; CompNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).TotalComponents; ++CompNum) { if (state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).Comp(CompNum).CurOpSchemeType != OpScheme::Demand) { @@ -2063,13 +2045,14 @@ void SetupReports(EnergyPlusData &state) } // now traverse plant loops and set fluid type index in all nodes on the loop - for (LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { - FluidIndex = state.dataPlnt->PlantLoop(LoopNum).FluidIndex; + for (int LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { + int FluidIndex = state.dataPlnt->PlantLoop(LoopNum).FluidIndex; for (DataPlant::LoopSideLocation LoopSideNum : DataPlant::LoopSideKeys) { state.dataLoopNodes->Node(state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).NodeNumIn).FluidIndex = FluidIndex; state.dataLoopNodes->Node(state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).NodeNumOut).FluidIndex = FluidIndex; - for (BranchNum = 1; BranchNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).TotalBranches; ++BranchNum) { - for (CompNum = 1; CompNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).TotalComponents; ++CompNum) { + for (int BranchNum = 1; BranchNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).TotalBranches; ++BranchNum) { + for (int CompNum = 1; CompNum <= state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).TotalComponents; + ++CompNum) { state.dataLoopNodes->Node(state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).Comp(CompNum).NodeNumIn) .FluidIndex = FluidIndex; state.dataLoopNodes->Node(state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).Branch(BranchNum).Comp(CompNum).NodeNumOut) @@ -2078,6 +2061,159 @@ void SetupReports(EnergyPlusData &state) } } } // plant loops + + // Plant topology report + // auto &orp = state.dataOutRptPredefined; + // MJW ToDo: Tabular report inputs haven't been read yet - move that or just skip checking if the report is requested? + // if (orp->reportName(orp->pdrTopology).show) { + + // constexpr std::string_view plantLoop = "PlantLoop"; + int rowCounter = 1; + for (int loopNum = 1; loopNum <= state.dataPlnt->TotNumLoops; ++loopNum) { + fillPlantCondenserTopology(state, state.dataPlnt->PlantLoop(loopNum), rowCounter); + } + + // constexpr std::string_view condenserLoop = "CondenserLoop"; + // for (int loopNum = state.dataHVACGlobal->NumPlantLoops + 1; loopNum <= (state.dataHVACGlobal->NumPlantLoops + + // state.dataHVACGlobal->NumCondLoops); + // ++loopNum) { + // fillPlantCondenserTopology(state, condenserLoop, state.dataPlnt->PlantLoop(loopNum)); + // } + // } +} + +void fillPlantCondenserTopology(EnergyPlusData &state, DataPlant::PlantLoopData &thisLoop, int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // int repOffset = 0; + // if (thisLoop.TypeOfLoop == DataPlant::LoopType::Condenser) { + // // Shift column pointers for condenser loop subtable + // repOffset = orp->pdchTopCondCompType - orp->pdchTopPlantCompType; + // } + std::string_view const loopType = DataPlant::loopTypeNames[static_cast(thisLoop.TypeOfLoop)]; + for (DataPlant::LoopSideLocation LoopSideNum : {DataPlant::LoopSideLocation::Supply, DataPlant::LoopSideLocation::Demand}) { + auto &thisLoopSide = thisLoop.LoopSide(LoopSideNum); + std::string_view const loopSide = DataPlant::DemandSupplyNames[static_cast(LoopSideNum)]; + + // OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompType + repOffset, thisLoopSide.loopSideDescription, loopType); + // OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide + repOffset, thisLoopSide.loopSideDescription, loopSide); + + // s->pdstTopPlantLoop2 = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement 2"); + // s->pdchTopPlantLoopType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Type"); + // s->pdchTopPlantLoopName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Name"); + // s->pdchTopPlantSide2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Side"); + // s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), thisLoop.Name); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), loopSide); + ++rowCounter; + + // Report for first branch + auto &thisBranch = thisLoopSide.Branch(1); + constexpr std::string_view branch = "Branch"; + // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); + // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); + + for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { + auto &thisComp = thisBranch.Comp(compNum); + // fillPlantToplogyRow(state, thisComp.Name, thisComp.TypeOf, loopSide, branch, thisBranch.Name, thisLoop.FluidName, repOffset); + fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); + } + + if (thisLoopSide.TotalBranches >= 3) { + // splitter + if (thisLoopSide.Splitter.Exists) { + constexpr std::string_view splitter = "Splitter"; + // fillPlantToplogyRow(state, thisLoopSide.Splitter.Name, splitter, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); + fillPlantToplogySplitterMixerRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Splitter.Name, rowCounter); + } + + // parallel branches + for (int branchNum = 2; branchNum <= thisLoopSide.TotalBranches - 1; ++branchNum) { + auto &thisBranch = thisLoopSide.Branch(branchNum); + // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); + // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); + + for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { + auto &thisComp = thisBranch.Comp(compNum); + // fillPlantToplogyRow(state, thisComp.Name, thisComp.TypeOf, loopSide, branch, thisBranch.Name, thisLoop.FluidName, repOffset); + fillPlantToplogyComponentRow2( + state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); + } + } + + // mixer + if (thisLoopSide.Mixer.Exists) { + constexpr std::string_view mixer = "Mixer"; + // fillPlantToplogyRow(state, thisLoopSide.Mixer.Name, mixer, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); + fillPlantToplogySplitterMixerRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Mixer.Name, rowCounter); + } + + // Outlet Branch + auto &thisBranch = thisLoopSide.Branch(thisLoopSide.TotalBranches); + // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); + // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); + for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { + auto &thisComp = thisBranch.Comp(compNum); + // fillPlantToplogyRow(state, thisComp.Name, thisComp.TypeOf, loopSide, branch, thisBranch.Name, thisLoop.FluidName, repOffset); + fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); + } + } + } +} + +// void fillPlantToplogyRow(EnergyPlusData &state, +// const std::string_view &compName, +// const std::string_view &compType, +// const std::string_view &side, +// const std::string_view &parentType, +// const std::string_view &parentName, +// const std::string_view &fluidName, +// const int reportOffset) +//{ +// auto &orp = state.dataOutRptPredefined; +// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompType + reportOffset, compName, compType); +// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide + reportOffset, compName, side); +// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantParType + reportOffset, compName, parentType); +// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantParName + reportOffset, compName, parentName); +// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantConType + reportOffset, compName, fluidName); +// } + +void fillPlantToplogySplitterMixerRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &splitterMixerName, + int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), loopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), side); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSplitMixName2, format("{}", rowCounter), splitterMixerName); + ++rowCounter; +} +void fillPlantToplogyComponentRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &branchName, + const std::string_view &compType, + const std::string_view &compName, + int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // s->pdchTopPlantBranchName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Branch Name"); + // s->pdchTopPlantCompType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Type"); + // s->pdchTopPlantCompName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), loopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), side); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantBranchName2, format("{}", rowCounter), branchName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompType2, format("{}", rowCounter), compType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompName2, format("{}", rowCounter), compName); + ++rowCounter; } void InitializeLoops(EnergyPlusData &state, bool const FirstHVACIteration) // true if first iteration of the simulation diff --git a/src/EnergyPlus/Plant/PlantManager.hh b/src/EnergyPlus/Plant/PlantManager.hh index f1896467fb5..bfa81f5c9e6 100644 --- a/src/EnergyPlus/Plant/PlantManager.hh +++ b/src/EnergyPlus/Plant/PlantManager.hh @@ -79,7 +79,35 @@ namespace PlantManager { void SetupReports(EnergyPlusData &state); - void InitializeLoops(EnergyPlusData &state, bool FirstHVACIteration); // true if first iteration of the simulation + void fillPlantCondenserTopology(EnergyPlusData &state, DataPlant::PlantLoopData &thisLoop, int &rowCounter); + + // void fillPlantToplogyRow(EnergyPlusData &state, + // const std::string_view &compName, + // const std::string_view &compType, + // const std::string_view &side, + // const std::string_view &parentType, + // const std::string_view &parentName, + // const std::string_view &fluidName, + // const int reportOffset); + + void fillPlantToplogySplitterMixerRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &splitterMixerName, + int &rowCounter); + + void fillPlantToplogyComponentRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &branchName, + const std::string_view &compType, + const std::string_view &compName, + int &rowCounter); + + void InitializeLoops(EnergyPlusData &state, + bool FirstHVACIteration); // true if first iteration of the simulation void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state); diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 6b0224d10b7..7fd50003693 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -898,6 +898,10 @@ void InitEnergyReports(EnergyPlusData &state) } } + reportAirLoopToplogy(state); + + reportZoneEquipmentToplogy(state); + state.dataSysRpts->OneTimeFlag_InitEnergyReports = false; } @@ -4760,6 +4764,138 @@ void ReportAirLoopConnections(EnergyPlusData &state) } } +void reportAirLoopToplogy(EnergyPlusData &state) +{ + // s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); + // s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); + // s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); + // s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); + // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); + // s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); + // s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); + // s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); + // s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); + + auto &orp = state.dataOutRptPredefined; + int rowCounter = 1; + for (int AirLoopNum = 1; AirLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys; ++AirLoopNum) { + auto &pas = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), pas.Name); + ++rowCounter; + for (int BranchNum = 1; BranchNum <= pas.NumBranches; ++BranchNum) { + auto &pasBranch = pas.Branch(BranchNum); + for (int CompNum = 1; CompNum <= pasBranch.TotalComponents; ++CompNum) { + auto &pasBranchComp = pasBranch.Comp(CompNum); + fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + for (int SubCompNum = 1; SubCompNum <= pasBranchComp.NumSubComps; ++SubCompNum) { + auto &pasBranchSubComp = pasBranchComp.SubComp(SubCompNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); + fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + for (int SubSubCompNum = 1; SubSubCompNum <= pasBranchSubComp.NumSubSubComps; ++SubSubCompNum) { + auto &pasBranchSubSubComp = pasBranchSubComp.SubSubComp(SubSubCompNum); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSubSubCompType, format("{}", rowCounter), pasBranchSubSubComp.TypeOf); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSubSubCompName, format("{}", rowCounter), pasBranchSubSubComp.Name); + fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + } + } + } + } + } + + // s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); + // s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); + // s->pdchTopAirSupplyPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Type"); + // s->pdchTopAirSupplyPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Name"); + // s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); + // s->pdchTopAirTermUnitType = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Type"); + // s->pdchTopAirTermUnitName = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Name"); + // s->pdchTopAirReturnPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Type"); + // s->pdchTopAirReturnPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Name"); + + rowCounter = 1; +} + +void fillAirloopToplogyComponentRow(EnergyPlusData &state, + const std::string_view &loopName, + const std::string_view &branchName, + const std::string_view &compType, + const std::string_view &compName, + int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); + // s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); + // s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); + // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), loopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirBranchName, format("{}", rowCounter), branchName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompType, format("{}", rowCounter), compType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompName, format("{}", rowCounter), compName); + ++rowCounter; +} + +void reportZoneEquipmentToplogy(EnergyPlusData &state) +{ + // s->pdstTopZnEqp = newPreDefSubTable(state, s->pdrTopology, "Zone Equipment Component Arrangement"); + // s->pdchTopZnEqpName = newPreDefColumn(state, s->pdstTopZnEqp, "Zone Name"); + // s->pdchTopZnEqpCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Component Type"); + // s->pdchTopZnEqpCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Component Name"); + // s->pdchTopZnEqpSubCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Component Type"); + // s->pdchTopZnEqpSubCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Component Name"); + // s->pdchTopZnEqpSubSubCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Sub-Component Type"); + // s->pdchTopZnEqpSubSubCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Sub-Sub-Component Name"); + + auto &orp = state.dataOutRptPredefined; + int rowCounter = 1; + for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { + const std::string_view zoneName = state.dataHeatBal->Zone(zoneNum).Name; + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpName, format("{}", rowCounter), zoneName); + ++rowCounter; + if (!state.dataZoneEquip->ZoneEquipConfig(zoneNum).IsControlled) continue; + auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); + for (int CompNum = 1; CompNum <= zel.NumOfEquipTypes; ++CompNum) { + auto &zelEquipData = zel.EquipData(CompNum); + fillZoneEquipToplogyComponentRow(state, zoneName, zelEquipData.TypeOf, zelEquipData.Name, rowCounter); + for (int SubCompNum = 1; SubCompNum <= zelEquipData.NumSubEquip; ++SubCompNum) { + auto &zelSubEquipData = zelEquipData.SubEquipData(SubCompNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpSubCompType, format("{}", rowCounter), zelSubEquipData.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpSubCompName, format("{}", rowCounter), zelSubEquipData.Name); + fillZoneEquipToplogyComponentRow(state, zoneName, zelEquipData.TypeOf, zelEquipData.Name, rowCounter); + for (int SubSubCompNum = 1; SubSubCompNum <= zelSubEquipData.NumSubSubEquip; ++SubSubCompNum) { + auto &zelSubSubEquipData = zelSubEquipData.SubSubEquipData(SubSubCompNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpSubCompType, format("{}", rowCounter), zelSubEquipData.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpSubCompName, format("{}", rowCounter), zelSubEquipData.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopZnEqpSubSubCompType, format("{}", rowCounter), zelSubSubEquipData.TypeOf); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopZnEqpSubSubCompName, format("{}", rowCounter), zelSubSubEquipData.Name); + fillZoneEquipToplogyComponentRow(state, zoneName, zelEquipData.TypeOf, zelEquipData.Name, rowCounter); + } + } + } + } +} + +void fillZoneEquipToplogyComponentRow( + EnergyPlusData &state, const std::string_view &zoneName, const std::string_view &compType, const std::string_view &compName, int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // s->pdstTopZnEqp = newPreDefSubTable(state, s->pdrTopology, "Zone Equipment Component Arrangement"); + // s->pdchTopZnEqpName = newPreDefColumn(state, s->pdstTopZnEqp, "Zone Name"); + // s->pdchTopZnEqpCompType = newPreDefColumn(state, s->pdstTopZnEqp, "Component Type"); + // s->pdchTopZnEqpCompName = newPreDefColumn(state, s->pdstTopZnEqp, "Component Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpName, format("{}", rowCounter), zoneName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpCompType, format("{}", rowCounter), compType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopZnEqpCompName, format("{}", rowCounter), compName); + ++rowCounter; +} + // End of Reporting subroutines for the SimAir Module // ***************************************************************************** diff --git a/src/EnergyPlus/SystemReports.hh b/src/EnergyPlus/SystemReports.hh index 4300aa3e7fb..1a1a0832f04 100644 --- a/src/EnergyPlus/SystemReports.hh +++ b/src/EnergyPlus/SystemReports.hh @@ -331,6 +331,20 @@ namespace SystemReports { void ReportAirLoopConnections(EnergyPlusData &state); + void reportAirLoopToplogy(EnergyPlusData &state); + + void fillAirloopToplogyComponentRow(EnergyPlusData &state, + const std::string_view &loopName, + const std::string_view &branchName, + const std::string_view &compType, + const std::string_view &compName, + int &rowCounter); + + void reportZoneEquipmentToplogy(EnergyPlusData &state); + + void fillZoneEquipToplogyComponentRow( + EnergyPlusData &state, const std::string_view &zoneName, const std::string_view &compType, const std::string_view &compName, int &rowCounter); + // End of Reporting subroutines for the SimAir Module // ***************************************************************************** From d52cd2b826f455f517218e539e5d0007a66fde45 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 15 Feb 2024 16:48:29 -0600 Subject: [PATCH 010/115] Initial pdchDCVType --- src/EnergyPlus/MixedAir.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc index 2d2e4035d60..69f3f902a42 100644 --- a/src/EnergyPlus/MixedAir.cc +++ b/src/EnergyPlus/MixedAir.cc @@ -2792,6 +2792,8 @@ void InitOAController(EnergyPlusData &state, int const OAControllerNum, bool con state.dataOutRptPredefined->pdchDCVMethod, zoneName, OAFlowCalcMethodNames[static_cast(thisMechVentZone.ZoneOAFlowMethod)]); + OutputReportPredefined::PreDefTableEntry(state, + state.dataOutRptPredefined->pdchDCVType, zoneName, static_cast(vent_mech.SystemOAMethod), 6); if (thisMechVentZone.ZoneOASchPtr > 0) { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchDCVOASchName, zoneName, GetScheduleName(state, thisMechVentZone.ZoneOASchPtr)); From 4e8a4a672db09ee5557ffe03cf4f41d5ad5ea907 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 19 Feb 2024 13:59:14 -0600 Subject: [PATCH 011/115] Add type string to System Summary DCV table --- src/EnergyPlus/DataSizing.hh | 13 +++++++++++++ src/EnergyPlus/MixedAir.cc | 2 +- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/EnergyPlus/DataSizing.hh b/src/EnergyPlus/DataSizing.hh index c9a2c4c6998..930c49f2695 100644 --- a/src/EnergyPlus/DataSizing.hh +++ b/src/EnergyPlus/DataSizing.hh @@ -206,6 +206,19 @@ namespace DataSizing { Num }; + constexpr std::array(SysOAMethod::Num)> SysOAMethodNames{ + "Zone Sum", + "Ventilation Rate Procedure", + "IAQ Proc", + "Proportional - Sch Occupancy", + "IAQ Proc - Generic Contaminant", + "IAQ Proc - Max Gen Cont or CO2.", + "Proportional - Des Occupancy", + "Proportional - Des OA Rate", + "Simplified Procure", + "Ventilation Rate Procedure Level"}; + + // Zone HVAC Equipment Sizing Option enum class DesignSizingType { diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc index 69f3f902a42..8139da2408f 100644 --- a/src/EnergyPlus/MixedAir.cc +++ b/src/EnergyPlus/MixedAir.cc @@ -2793,7 +2793,7 @@ void InitOAController(EnergyPlusData &state, int const OAControllerNum, bool con zoneName, OAFlowCalcMethodNames[static_cast(thisMechVentZone.ZoneOAFlowMethod)]); OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchDCVType, zoneName, static_cast(vent_mech.SystemOAMethod), 6); + state.dataOutRptPredefined->pdchDCVType, zoneName, SysOAMethodNames[static_cast(vent_mech.SystemOAMethod)]); if (thisMechVentZone.ZoneOASchPtr > 0) { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchDCVOASchName, zoneName, GetScheduleName(state, thisMechVentZone.ZoneOASchPtr)); From b65030535a68f86babcc4ffc185f0762df497a18 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 19 Feb 2024 15:30:35 -0600 Subject: [PATCH 012/115] Format fixing --- src/EnergyPlus/DataSizing.hh | 22 ++++++++++------------ src/EnergyPlus/MixedAir.cc | 4 ++-- 2 files changed, 12 insertions(+), 14 deletions(-) diff --git a/src/EnergyPlus/DataSizing.hh b/src/EnergyPlus/DataSizing.hh index 930c49f2695..ff9684bf63c 100644 --- a/src/EnergyPlus/DataSizing.hh +++ b/src/EnergyPlus/DataSizing.hh @@ -206,18 +206,16 @@ namespace DataSizing { Num }; - constexpr std::array(SysOAMethod::Num)> SysOAMethodNames{ - "Zone Sum", - "Ventilation Rate Procedure", - "IAQ Proc", - "Proportional - Sch Occupancy", - "IAQ Proc - Generic Contaminant", - "IAQ Proc - Max Gen Cont or CO2.", - "Proportional - Des Occupancy", - "Proportional - Des OA Rate", - "Simplified Procure", - "Ventilation Rate Procedure Level"}; - + constexpr std::array(SysOAMethod::Num)> SysOAMethodNames{"Zone Sum", + "Ventilation Rate Procedure", + "IAQ Proc", + "Proportional - Sch Occupancy", + "IAQ Proc - Generic Contaminant", + "IAQ Proc - Max Gen Cont or CO2.", + "Proportional - Des Occupancy", + "Proportional - Des OA Rate", + "Simplified Procure", + "Ventilation Rate Procedure Level"}; // Zone HVAC Equipment Sizing Option enum class DesignSizingType diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc index 8139da2408f..67498cc6aa1 100644 --- a/src/EnergyPlus/MixedAir.cc +++ b/src/EnergyPlus/MixedAir.cc @@ -2792,8 +2792,8 @@ void InitOAController(EnergyPlusData &state, int const OAControllerNum, bool con state.dataOutRptPredefined->pdchDCVMethod, zoneName, OAFlowCalcMethodNames[static_cast(thisMechVentZone.ZoneOAFlowMethod)]); - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchDCVType, zoneName, SysOAMethodNames[static_cast(vent_mech.SystemOAMethod)]); + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDCVType, zoneName, SysOAMethodNames[static_cast(vent_mech.SystemOAMethod)]); if (thisMechVentZone.ZoneOASchPtr > 0) { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchDCVOASchName, zoneName, GetScheduleName(state, thisMechVentZone.ZoneOASchPtr)); From 1656a5a0ebede982c237844360d87427aaa36612 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 19 Feb 2024 16:19:39 -0600 Subject: [PATCH 013/115] Add Minimum Loop Flow Rate to component sizing table and EIO --- src/EnergyPlus/Plant/PlantManager.cc | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 7a841a988a3..0808ceed643 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -3254,6 +3254,20 @@ void SizePlantLoop(EnergyPlusData &state, } } + if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Plant) { + BaseSizer::reportSizerOutput(state, + "PlantLoop", + state.dataPlnt->PlantLoop(LoopNum).Name, + "Minimum Loop Flow Rate [m3/s]", + state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); + } else if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Condenser) { + BaseSizer::reportSizerOutput(state, + "CondenserLoop", + state.dataPlnt->PlantLoop(LoopNum).Name, + "Minimum Loop Flow Rate [m3/s]", + state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); + } + // should now have plant volume, calculate plant volume's mass for fluid type if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { FluidDensity = GetDensityGlycol( From 74a2d25fa1678a0e32dbdd2d4f420f3a616f89de Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 20 Feb 2024 13:36:49 -0600 Subject: [PATCH 014/115] Add support for Supplemental heat high shutoff temperature in equipment heating coils table --- src/EnergyPlus/HVACMultiSpeedHeatPump.cc | 6 ++++++ src/EnergyPlus/UnitarySystem.cc | 7 +++++++ 2 files changed, 13 insertions(+) diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index 2a87130f7d1..4aa60c2d9b8 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -76,6 +76,7 @@ #include #include #include +#include #include #include #include @@ -454,6 +455,8 @@ namespace HVACMultiSpeedHeatPump { // PURPOSE OF THIS SUBROUTINE: // This routine will get the input required by the multispeed heat pump model + using namespace OutputReportPredefined; + // PARAMETERS static constexpr std::string_view RoutineName("GetMSHeatPumpInput: "); // include trailing blank space static constexpr std::string_view RoutineNameNoColon("GetMSHeatPumpInput"); @@ -1244,6 +1247,9 @@ namespace HVACMultiSpeedHeatPump { ShowContinueError(state, format("The input value is {:.2R}", Numbers(3))); ErrorsFound = true; } + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, thisMSHP.DXHeatCoilName, thisMSHP.SuppMaxOATemp); + thisMSHP.AuxOnCyclePower = Numbers(4); thisMSHP.AuxOffCyclePower = Numbers(5); diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 7ed2cc99090..1668dc99ebf 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -82,6 +82,7 @@ #include #include #include +#include #include #include #include @@ -3497,6 +3498,8 @@ namespace UnitarySystems { int const ZoneOAUnitNum) { + using namespace OutputReportPredefined; + static constexpr std::string_view unitarySysHeatPumpPerformanceObjectType("UnitarySystemPerformance:Multispeed"); std::string const &cCurrentModuleObject = input_data.system_type; @@ -6516,6 +6519,10 @@ namespace UnitarySystems { if (this->m_MaxOATSuppHeat == 21.0 && this->m_DehumidControlType_Num == DehumCtrlType::CoolReheat) { this->m_MaxOATSuppHeat = 999.0; } + if (this->m_SuppCoilExists) { + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, this->m_HeatingCoilName, this->m_MaxOATSuppHeat); + } if (this->m_MaxCoolAirVolFlow > 0.0 && this->m_MaxHeatAirVolFlow > 0.0 && this->m_MaxNoCoolHeatAirVolFlow >= 0.0 && !this->m_RequestAutoSize) { From 623592ed26eaf59d3916aac54a3f4f3925d07579 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 21 Feb 2024 10:59:11 -0600 Subject: [PATCH 015/115] Airloop Demand Toplogy Report --- src/EnergyPlus/DataAirLoop.hh | 3 + src/EnergyPlus/DataHVACGlobals.hh | 3 + src/EnergyPlus/OutputReportPredefined.cc | 4 + src/EnergyPlus/OutputReportPredefined.hh | 4 + src/EnergyPlus/SimAirServingZones.cc | 15 ++- src/EnergyPlus/SystemReports.cc | 136 ++++++++++++++++++++++- 6 files changed, 161 insertions(+), 4 deletions(-) diff --git a/src/EnergyPlus/DataAirLoop.hh b/src/EnergyPlus/DataAirLoop.hh index 7dbbdef2b64..5f7a88e289c 100644 --- a/src/EnergyPlus/DataAirLoop.hh +++ b/src/EnergyPlus/DataAirLoop.hh @@ -86,6 +86,9 @@ namespace DataAirLoop { Array1D_int TermUnitCoolSizingIndex; // Air terminal sizing numbers for zones cooled by this air loop Array1D_int TermUnitHeatSizingIndex; // Air terminal sizing numbers for zones heated by this air loop Array1D SupplyDuctType; // 1=main, 2=cooling, 3=heating, 4=other + Array1D_int SupplyDuctBranchNum; // Supply duct branch number + Array1D_int SupplyAirPathNum; // Supply air path indexes + Array1D_int ReturnAirPathNum; // Return air path indexes }; struct AirLoopOutsideAirConnectData diff --git a/src/EnergyPlus/DataHVACGlobals.hh b/src/EnergyPlus/DataHVACGlobals.hh index 2b7d6e1989f..bc45fd6470f 100644 --- a/src/EnergyPlus/DataHVACGlobals.hh +++ b/src/EnergyPlus/DataHVACGlobals.hh @@ -124,6 +124,9 @@ namespace DataHVACGlobals { Num }; + static constexpr std::array(AirDuctType::Num)> airDuctTypeNames = { + "Main", "Cooling", "Heating", "Other", "Return Air Bypass"}; + int constexpr Cooling(2); int constexpr Heating(3); diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index d0db563aeff..aa2934a74c6 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -915,6 +915,7 @@ namespace OutputReportPredefined { s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); + s->pdchTopAirUpSplitMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Upstream Splitter or Mixer Name"); s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); @@ -922,9 +923,12 @@ namespace OutputReportPredefined { s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); + s->pdchTopAirDownSplitMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Downstream Splitter or Mixer Name"); s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); + s->pdchTopAirSupplyBranchName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Branch Name"); + s->pdchTopAirSupplyDuctType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Branch Type"); s->pdchTopAirSupplyPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Type"); s->pdchTopAirSupplyPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Name"); s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 388bcd49efa..b20d8339233 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -887,6 +887,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdstTopAirLoop = 0; int pdchTopAirLoopName = 0; + int pdchTopAirUpSplitMixName = 0; int pdchTopAirBranchName = 0; int pdchTopAirCompType = 0; int pdchTopAirCompName = 0; @@ -894,9 +895,12 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopAirSubCompName = 0; int pdchTopAirSubSubCompType = 0; int pdchTopAirSubSubCompName = 0; + int pdchTopAirDownSplitMixName = 0; int pdstTopAirDemand = 0; int pdchTopAirDemandName = 0; + int pdchTopAirSupplyBranchName = 0; + int pdchTopAirSupplyDuctType = 0; int pdchTopAirSupplyPCompType = 0; int pdchTopAirSupplyPCompName = 0; int pdchTopAirZoneName = 0; diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc index d1cc99afe4d..7d89fb5ff59 100644 --- a/src/EnergyPlus/SimAirServingZones.cc +++ b/src/EnergyPlus/SimAirServingZones.cc @@ -479,7 +479,9 @@ void GetAirPathData(EnergyPlusData &state) // Allocate the return air node arrays airLoopZoneInfo.AirLoopReturnNodeNum.allocate(airLoopZoneInfo.NumReturnNodes); airLoopZoneInfo.ZoneEquipReturnNodeNum.allocate(airLoopZoneInfo.NumReturnNodes); + airLoopZoneInfo.ReturnAirPathNum.allocate(airLoopZoneInfo.NumReturnNodes); // fill the return air node arrays with node numbers + airLoopZoneInfo.ReturnAirPathNum(1) = 0; airLoopZoneInfo.AirLoopReturnNodeNum(1) = GetOnlySingleNode(state, Alphas(6), ErrorsFound, @@ -626,10 +628,15 @@ void GetAirPathData(EnergyPlusData &state) airLoopZoneInfo.ZoneEquipSupplyNodeNum.allocate(airLoopZoneInfo.NumSupplyNodes); airLoopZoneInfo.AirLoopSupplyNodeNum.allocate(airLoopZoneInfo.NumSupplyNodes); airLoopZoneInfo.SupplyDuctType.allocate(airLoopZoneInfo.NumSupplyNodes); + airLoopZoneInfo.SupplyDuctBranchNum.allocate(airLoopZoneInfo.NumSupplyNodes); + airLoopZoneInfo.SupplyAirPathNum.allocate(airLoopZoneInfo.NumSupplyNodes); + // Fill the supply node arrays with node numbers for (I = 1; I <= airLoopZoneInfo.NumSupplyNodes; ++I) { airLoopZoneInfo.ZoneEquipSupplyNodeNum(I) = NodeNums(I); airLoopZoneInfo.SupplyDuctType(I) = DataHVACGlobals::AirDuctType::Invalid; + airLoopZoneInfo.SupplyDuctBranchNum(I) = 0; + airLoopZoneInfo.SupplyAirPathNum(I) = 0; } ErrInList = false; GetNodeNums(state, @@ -979,7 +986,7 @@ void GetAirPathData(EnergyPlusData &state) primaryAirSystems.Mixer.BranchNumIn(NodeNum) = 0; for (BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) { - if (primaryAirSystems.Branch(BranchNum).NodeNumIn == primaryAirSystems.Mixer.NodeNumIn(NodeNum)) { + if (primaryAirSystems.Branch(BranchNum).NodeNumOut == primaryAirSystems.Mixer.NodeNumIn(NodeNum)) { primaryAirSystems.Mixer.BranchNumIn(NodeNum) = BranchNum; break; } @@ -1547,6 +1554,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE // eliminate the duplicates to find the number of nodes in the supply air path NumSupAirPathNodes = NumAllSupAirPathNodes - NumSupAirPathIntNodes; SupAirPathNodeNum = 0; + state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNode.allocate(NumSupAirPathOutNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).Node.allocate(NumSupAirPathNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).NodeType.allocate(NumSupAirPathNodes); @@ -1604,6 +1612,8 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE int ZoneSideNodeNum = thisAirToZoneNodeInfo.ZoneEquipSupplyNodeNum(OutNum); // find the corresponding branch number int OutBranchNum = thisPrimaryAirSys.OutletBranchNum[OutNum - 1]; + thisAirToZoneNodeInfo.SupplyDuctBranchNum(OutNum) = OutBranchNum; + // find the supply air path corresponding to each air loop outlet node int SupAirPathNum = 0; // loop over the air loop's output nodes @@ -1614,8 +1624,10 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE } } int NumSupAirPathOutNodes = 0; + thisAirToZoneNodeInfo.SupplyAirPathNum(OutNum) = SupAirPathNum; if (SupAirPathNum > 0) { NumSupAirPathOutNodes = state.dataZoneEquip->SupplyAirPath(SupAirPathNum).NumOutletNodes; + } // Now Loop over the Supply Air Path outlet nodes and find out which zone and which air terminal @@ -2302,6 +2314,7 @@ void ConnectReturnNodes(EnergyPlusData &state) if (AirToZoneNodeInfo(sysNum).NumReturnNodes > 0) { if (thisRetPath.OutletNodeNum == AirToZoneNodeInfo(sysNum).ZoneEquipReturnNodeNum(1)) { airLoopNum = sysNum; + AirToZoneNodeInfo(sysNum).ReturnAirPathNum(1) = retPathNum; break; } } diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 7fd50003693..2b421e3c7c8 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4778,12 +4778,25 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &orp = state.dataOutRptPredefined; int rowCounter = 1; - for (int AirLoopNum = 1; AirLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys; ++AirLoopNum) { - auto &pas = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum); + for (int airLoopNum = 1; airLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys; ++airLoopNum) { + auto &pas = state.dataAirSystemsData->PrimaryAirSystems(airLoopNum); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), pas.Name); ++rowCounter; for (int BranchNum = 1; BranchNum <= pas.NumBranches; ++BranchNum) { auto &pasBranch = pas.Branch(BranchNum); + if (pas.Splitter.Exists) { + for (int outNum : pas.Splitter.BranchNumOut) { + if (outNum == BranchNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirUpSplitMixName, format("{}", rowCounter), pas.Splitter.Name); + break; + } + } + } + if (pas.Mixer.Exists) { + if (pas.Mixer.BranchNumOut == BranchNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirUpSplitMixName, format("{}", rowCounter), pas.Mixer.Name); + } + } for (int CompNum = 1; CompNum <= pasBranch.TotalComponents; ++CompNum) { auto &pasBranchComp = pasBranch.Comp(CompNum); fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); @@ -4805,11 +4818,26 @@ void reportAirLoopToplogy(EnergyPlusData &state) } } } + if (pas.Mixer.Exists) { + for (int inNum : pas.Mixer.BranchNumIn) { + if (inNum == BranchNum) { + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirDownSplitMixName, format("{}", rowCounter - 1), pas.Mixer.Name); + break; + } + } + } + if (pas.Splitter.Exists) { + if (pas.Splitter.BranchNumIn == BranchNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDownSplitMixName, format("{}", rowCounter - 1), pas.Splitter.Name); + } + } } } - // s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); + // s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); // s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); + // s->pdchTopAirSupplyBranchName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Branch Name"); // s->pdchTopAirSupplyPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Type"); // s->pdchTopAirSupplyPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Name"); // s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); @@ -4819,6 +4847,108 @@ void reportAirLoopToplogy(EnergyPlusData &state) // s->pdchTopAirReturnPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Name"); rowCounter = 1; + for (int airLoopNum = 1; airLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys; ++airLoopNum) { + auto &pas = state.dataAirSystemsData->PrimaryAirSystems(airLoopNum); + auto &thisAtoZInfo = state.dataAirLoop->AirToZoneNodeInfo(airLoopNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + ++rowCounter; + if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { + auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); + auto &thisBranch = pas.Branch(pas.InletBranchNum[0]); + for (int compNum = 1; compNum <= thisReturnPath.NumOfComponents; ++compNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirReturnPCompType, format("{}", rowCounter), thisReturnPath.ComponentType(compNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirReturnPCompName, format("{}", rowCounter), thisReturnPath.ComponentName(compNum)); + ++rowCounter; + } + } + for (int ductNum = 1; ductNum <= thisAtoZInfo.NumSupplyNodes; ++ductNum) { + auto &thisBranch = pas.Branch(thisAtoZInfo.SupplyDuctBranchNum(ductNum)); + if (thisAtoZInfo.SupplyAirPathNum(ductNum) > 0) { + auto &thisSupplyPath = state.dataZoneEquip->SupplyAirPath(thisAtoZInfo.SupplyAirPathNum(ductNum)); + for (int compNum = 1; compNum <= thisSupplyPath.NumOfComponents; ++compNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompType, format("{}", rowCounter), thisSupplyPath.ComponentType(compNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompName, format("{}", rowCounter), thisSupplyPath.ComponentName(compNum)); + ++rowCounter; + } + if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Cooling || thisBranch.DuctType == DataHVACGlobals::AirDuctType::Main) { + for (int zoneNum : thisAtoZInfo.CoolCtrlZoneNums) { + auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); + for (auto &thisCoolADU : thisZoneEquipConfig.AirDistUnitCool) { + if (thisCoolADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirSupplyDuctType, + format("{}", rowCounter), + DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); + OutputReportPredefined::PreDefTableEntry( + state, + orp->pdchTopAirTermUnitType, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(thisCoolADU.AirDistUnitIndex).EquipType(1)); + OutputReportPredefined::PreDefTableEntry( + state, + orp->pdchTopAirTermUnitName, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(thisCoolADU.AirDistUnitIndex).EquipName(1)); + ++rowCounter; + } + } + } else if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Heating) { + for (int zoneNum : thisAtoZInfo.HeatCtrlZoneNums) { + auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); + for (auto &thisHeatADU : thisZoneEquipConfig.AirDistUnitHeat) { + if (thisHeatADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirSupplyDuctType, + format("{}", rowCounter), + DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); + OutputReportPredefined::PreDefTableEntry( + state, + orp->pdchTopAirTermUnitType, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(thisHeatADU.AirDistUnitIndex).EquipType(1)); + OutputReportPredefined::PreDefTableEntry( + state, + orp->pdchTopAirTermUnitName, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(thisHeatADU.AirDistUnitIndex).EquipName(1)); + ++rowCounter; + } + } + } + + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + ++rowCounter; + } + } + } } void fillAirloopToplogyComponentRow(EnergyPlusData &state, From dcc90a67c376e657f0b63636419a4539afa92512 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 21 Feb 2024 15:54:28 -0600 Subject: [PATCH 016/115] Repairs related to Airloop Demand Toplogy and in InitEnergyReports --- src/EnergyPlus/SystemReports.cc | 75 +++++++++++++++------------------ 1 file changed, 34 insertions(+), 41 deletions(-) diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 2b421e3c7c8..6e4db3b59c2 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -209,20 +209,22 @@ void InitEnergyReports(EnergyPlusData &state) } } } - } else if (thisZoneEquipList.EquipData(CompNum).OutletNodeNums(NodeCount) == - thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).InNode) { + } + if (thisZoneEquipList.EquipData(CompNum).OutletNodeNums(NodeCount) == + thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).OutNode) { thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).AirDistUnitIndex = CompNum; if (thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathExists) { for (int SAPNum = 1; SAPNum <= state.dataZoneEquip->NumSupplyAirPaths; ++SAPNum) { - for (int NodeIndex = 1; NodeIndex <= state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumSupplyNodes; - ++NodeIndex) { - if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).ZoneEquipSupplyNodeNum(NodeIndex) == - state.dataZoneEquip->SupplyAirPath(SAPNum).InletNodeNum) { - for (int BranchNum = 1; BranchNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).NumBranches; - ++BranchNum) { - if (state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).NodeNumOut == - state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).AirLoopSupplyNodeNum(NodeIndex)) { - thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyBranchIndex = BranchNum; + for (int SAPOutNode = 1; SAPOutNode <= state.dataZoneEquip->SupplyAirPath(SAPNum).NumOutletNodes; ++SAPOutNode) { + if (thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).InNode == + state.dataZoneEquip->SupplyAirPath(SAPNum).OutletNode(SAPOutNode)) { + thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathIndex = SAPNum; + for (int OutNum = 1; OutNum <= state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumSupplyNodes; + ++OutNum) { + if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).ZoneEquipSupplyNodeNum(OutNum) == + state.dataZoneEquip->SupplyAirPath(SAPNum).InletNodeNum) { + thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyBranchIndex = + state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).OutletBranchNum[OutNum - 1]; if (state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Splitter.Exists) { for (int MainBranchNum = 1; MainBranchNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).NumBranches; @@ -236,18 +238,12 @@ void InitEnergyReports(EnergyPlusData &state) } } else { // no splitter thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).MainBranchIndex = - thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathIndex; + thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyBranchIndex; } } } } } - - for (int SAPOutNode = 1; SAPOutNode <= state.dataZoneEquip->SupplyAirPath(SAPNum).NumOutletNodes; ++SAPOutNode) { - if (ZoneInletNodeNum == state.dataZoneEquip->SupplyAirPath(SAPNum).OutletNode(SAPOutNode)) { - thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathIndex = SAPNum; - } - } } } else { // no supply air path if (AirLoopNum > 0) { @@ -281,9 +277,6 @@ void InitEnergyReports(EnergyPlusData &state) } } } - } else { - - // Can't tell if there's an error based on this code...need to check logical flags separately } } } @@ -4885,6 +4878,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Cooling || thisBranch.DuctType == DataHVACGlobals::AirDuctType::Main) { for (int zoneNum : thisAtoZInfo.CoolCtrlZoneNums) { auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); + auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); for (auto &thisCoolADU : thisZoneEquipConfig.AirDistUnitCool) { if (thisCoolADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; OutputReportPredefined::PreDefTableEntry( @@ -4897,22 +4891,22 @@ void reportAirLoopToplogy(EnergyPlusData &state) DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); - OutputReportPredefined::PreDefTableEntry( - state, - orp->pdchTopAirTermUnitType, - format("{}", rowCounter), - state.dataDefineEquipment->AirDistUnit(thisCoolADU.AirDistUnitIndex).EquipType(1)); - OutputReportPredefined::PreDefTableEntry( - state, - orp->pdchTopAirTermUnitName, - format("{}", rowCounter), - state.dataDefineEquipment->AirDistUnit(thisCoolADU.AirDistUnitIndex).EquipName(1)); + auto &aduIndex = zel.EquipIndex(thisCoolADU.AirDistUnitIndex); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirTermUnitType, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(aduIndex).EquipType(1)); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirTermUnitName, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(aduIndex).EquipName(1)); ++rowCounter; } } } else if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Heating) { for (int zoneNum : thisAtoZInfo.HeatCtrlZoneNums) { auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); + auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); for (auto &thisHeatADU : thisZoneEquipConfig.AirDistUnitHeat) { if (thisHeatADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; OutputReportPredefined::PreDefTableEntry( @@ -4925,16 +4919,15 @@ void reportAirLoopToplogy(EnergyPlusData &state) DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); - OutputReportPredefined::PreDefTableEntry( - state, - orp->pdchTopAirTermUnitType, - format("{}", rowCounter), - state.dataDefineEquipment->AirDistUnit(thisHeatADU.AirDistUnitIndex).EquipType(1)); - OutputReportPredefined::PreDefTableEntry( - state, - orp->pdchTopAirTermUnitName, - format("{}", rowCounter), - state.dataDefineEquipment->AirDistUnit(thisHeatADU.AirDistUnitIndex).EquipName(1)); + auto &aduIndex = zel.EquipIndex(thisHeatADU.AirDistUnitIndex); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirTermUnitType, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(aduIndex).EquipType(1)); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirTermUnitName, + format("{}", rowCounter), + state.dataDefineEquipment->AirDistUnit(aduIndex).EquipName(1)); ++rowCounter; } } From e9386cc69ac059dd56b7e88ee4586c6b71b9222b Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 21 Feb 2024 15:55:08 -0600 Subject: [PATCH 017/115] Start connecting ADUs to supply path components --- src/EnergyPlus/DataZoneEquipment.hh | 1 + src/EnergyPlus/SimAirServingZones.cc | 7 +++++++ 2 files changed, 8 insertions(+) diff --git a/src/EnergyPlus/DataZoneEquipment.hh b/src/EnergyPlus/DataZoneEquipment.hh index cf21a6def33..310f3d145ab 100644 --- a/src/EnergyPlus/DataZoneEquipment.hh +++ b/src/EnergyPlus/DataZoneEquipment.hh @@ -510,6 +510,7 @@ namespace DataZoneEquipment { Array1D_int PlenumIndex; int NumOutletNodes; Array1D_int OutletNode; + Array1D_int OutletNodeSupplyPathCompNum; // Index to the supply path ComponentName and ComponentType lists for this outlet node int NumNodes; Array1D_int Node; Array1D NodeType; diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc index cd2d69ccc11..b88fb7213a8 100644 --- a/src/EnergyPlus/SimAirServingZones.cc +++ b/src/EnergyPlus/SimAirServingZones.cc @@ -1490,8 +1490,10 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE } EPVector supNode; EPVector supNodeType; + EPVector supNodeCompNum; supNode.allocate(NumAllSupAirPathNodes); supNodeType.allocate(NumAllSupAirPathNodes); + supNodeCompNum.allocate(NumAllSupAirPathNodes); // figure out the order of the splitter and plenum in the path, by flagging the first node of the component // as either a 'pathinlet' or a 'compinlet' @@ -1501,6 +1503,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE if (SplitterNum > 0) { ++SupAirPathNodeNum; supNode(SupAirPathNodeNum) = state.dataSplitterComponent->SplitterCond(SplitterNum).InletNode; + supNodeCompNum(SupAirPathNodeNum) = CompNum; if (CompNum == 1) { supNodeType(SupAirPathNodeNum) = DataZoneEquipment::AirNodeType::PathInlet; } else { @@ -1510,11 +1513,13 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE ++SplitterOutNum) { ++SupAirPathNodeNum; supNode(SupAirPathNodeNum) = state.dataSplitterComponent->SplitterCond(SplitterNum).OutletNode(SplitterOutNum); + supNodeCompNum(SupAirPathNodeNum) = CompNum; supNodeType(SupAirPathNodeNum) = DataZoneEquipment::AirNodeType::Invalid; } } else if (PlenumNum > 0) { ++SupAirPathNodeNum; supNode(SupAirPathNodeNum) = state.dataZonePlenum->ZoneSupPlenCond(PlenumNum).InletNode; + supNodeCompNum(SupAirPathNodeNum) = CompNum; if (CompNum == 1) { supNodeType(SupAirPathNodeNum) = DataZoneEquipment::AirNodeType::PathInlet; } else { @@ -1523,6 +1528,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE for (int PlenumOutNum = 1; PlenumOutNum <= state.dataZonePlenum->ZoneSupPlenCond(PlenumNum).NumOutletNodes; ++PlenumOutNum) { ++SupAirPathNodeNum; supNode(SupAirPathNodeNum) = state.dataZonePlenum->ZoneSupPlenCond(PlenumNum).OutletNode(PlenumOutNum); + supNodeCompNum(SupAirPathNodeNum) = CompNum; supNodeType(SupAirPathNodeNum) = DataZoneEquipment::AirNodeType::Invalid; } } @@ -1556,6 +1562,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE SupAirPathNodeNum = 0; state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNode.allocate(NumSupAirPathOutNodes); + state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNodeSupplyPathCompNum.allocate(NumSupAirPathOutNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).Node.allocate(NumSupAirPathNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).NodeType.allocate(NumSupAirPathNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).NumNodes = NumSupAirPathNodes; From 0c2abe70393c8555ff759263a2eb2e89c6b4366c Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Wed, 21 Feb 2024 16:27:45 -0600 Subject: [PATCH 018/115] Add support for sup heat high shutoff temp in AirLoopHVAC:UnitaryHeatPump:AirToAir and AirLoopHVAC:UnitaryHeatPump:WaterToAir --- src/EnergyPlus/Furnaces.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index ef16657bc20..db71c18fed7 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -84,6 +84,7 @@ #include #include #include +#include #include #include #include @@ -691,6 +692,8 @@ namespace Furnaces { std::string_view constexpr getUnitaryHeatOnly("GetUnitaryHeatOnly"); std::string_view constexpr getAirLoopHVACHeatCoolInput("GetAirLoopHVACHeatCoolInput"); + using namespace OutputReportPredefined; + // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int FurnaceNum; // The Furnace that you are currently loading input into int GetObjectNum; // The index to each specific object name @@ -3690,6 +3693,8 @@ namespace Furnaces { // Set maximum supply air temperature for supplemental heating coil thisFurnace.MaxOATSuppHeat = Numbers(5); + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, HeatingCoilName, thisFurnace.MaxOATSuppHeat); // set minimum outdoor temperature for compressor operation SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound); @@ -4516,6 +4521,8 @@ namespace Furnaces { // Set maximum supply air temperature for supplemental heating coil thisFurnace.MaxOATSuppHeat = Numbers(5); + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, HeatingCoilName, thisFurnace.MaxOATSuppHeat); // set minimum outdoor temperature for compressor operation SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound); From 2399e2333d1158a1925b2321021dd853938eb09c Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 27 Feb 2024 09:57:18 -0600 Subject: [PATCH 019/115] Clang fixes --- src/EnergyPlus/HVACFan.cc | 5 +++-- src/EnergyPlus/HVACMultiSpeedHeatPump.cc | 1 - src/EnergyPlus/SimAirServingZones.cc | 3 +-- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/EnergyPlus/HVACFan.cc b/src/EnergyPlus/HVACFan.cc index 5b8a028d137..5306b199586 100644 --- a/src/EnergyPlus/HVACFan.cc +++ b/src/EnergyPlus/HVACFan.cc @@ -314,9 +314,10 @@ namespace HVACFan { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchFanAutosized, name, m_designAirVolFlowRateWasAutosized ? "Yes" : "No"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, name, m_motorEff); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, name, 1- m_motorInAirFrac); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, name, 1 - m_motorInAirFrac); if (m_heatLossesDestination == ThermalLossDestination::ZoneGains) { - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, name, state.dataHeatBal->Zone(m_zoneNum).Name); + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchFanMotorHeatZone, name, state.dataHeatBal->Zone(m_zoneNum).Name); } OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index 4aa60c2d9b8..51c71e0181f 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -1250,7 +1250,6 @@ namespace HVACMultiSpeedHeatPump { OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, thisMSHP.DXHeatCoilName, thisMSHP.SuppMaxOATemp); - thisMSHP.AuxOnCyclePower = Numbers(4); thisMSHP.AuxOffCyclePower = Numbers(5); if (thisMSHP.AuxOnCyclePower < 0.0) { diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc index b88fb7213a8..88fc5fabb8d 100644 --- a/src/EnergyPlus/SimAirServingZones.cc +++ b/src/EnergyPlus/SimAirServingZones.cc @@ -1560,7 +1560,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE // eliminate the duplicates to find the number of nodes in the supply air path NumSupAirPathNodes = NumAllSupAirPathNodes - NumSupAirPathIntNodes; SupAirPathNodeNum = 0; - + state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNode.allocate(NumSupAirPathOutNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNodeSupplyPathCompNum.allocate(NumSupAirPathOutNodes); state.dataZoneEquip->SupplyAirPath(SupAirPath).Node.allocate(NumSupAirPathNodes); @@ -1634,7 +1634,6 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE thisAirToZoneNodeInfo.SupplyAirPathNum(OutNum) = SupAirPathNum; if (SupAirPathNum > 0) { NumSupAirPathOutNodes = state.dataZoneEquip->SupplyAirPath(SupAirPathNum).NumOutletNodes; - } // Now Loop over the Supply Air Path outlet nodes and find out which zone and which air terminal From 25e7e83d2e6c187ba1ba3be0322c28db5814cc3f Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 27 Feb 2024 16:15:53 -0600 Subject: [PATCH 020/115] Skeleton of new air terminal reporting --- src/EnergyPlus/SingleDuct.cc | 13 +++++++++ src/EnergyPlus/SingleDuct.hh | 2 ++ src/EnergyPlus/SizingManager.cc | 18 +++++------- src/EnergyPlus/SystemReports.cc | 52 +++++++++++++++++++++++++++++++++ src/EnergyPlus/SystemReports.hh | 2 ++ 5 files changed, 77 insertions(+), 10 deletions(-) diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 0252d2153c0..4cdef6902aa 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -80,6 +80,7 @@ #include #include #include +#include #include #include #include @@ -6511,6 +6512,18 @@ void SingleDuctAirTerminal::CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state) } } +void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) +{ + // calculates zone outdoor air volume flow rate using the supply air flow rate and OA fraction + if (this->AirLoopNum > 0) { + this->OutdoorAirFlowRate = + (this->sd_airterminalOutlet.AirMassFlowRate / state.dataEnvrn->StdRhoAir) * state.dataAirLoop->AirLoopFlow(this->AirLoopNum).OAFrac; + } else { + this->OutdoorAirFlowRate = 0.0; + } +} + + // End of Reporting subroutines for the Sys Module // ***************************************************************************** diff --git a/src/EnergyPlus/SingleDuct.hh b/src/EnergyPlus/SingleDuct.hh index f45c07cfe0d..8ad999becf0 100644 --- a/src/EnergyPlus/SingleDuct.hh +++ b/src/EnergyPlus/SingleDuct.hh @@ -270,6 +270,8 @@ namespace SingleDuct { void CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state); + void reportTerminalUnit(EnergyPlusData &state); + void UpdateSys(EnergyPlusData &state) const; void ReportSys(EnergyPlusData &state); diff --git a/src/EnergyPlus/SizingManager.cc b/src/EnergyPlus/SizingManager.cc index 9d2c1b6f5f4..ad51b9bd1e1 100644 --- a/src/EnergyPlus/SizingManager.cc +++ b/src/EnergyPlus/SizingManager.cc @@ -5509,32 +5509,30 @@ void UpdateTermUnitFinalZoneSizing(EnergyPlusData &state) } // begin std 229 air terminal new table + std::string oldADUname = format("{}-old", thisTUFZSizing.ADUName); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermZoneName, - thisTUFZSizing.ADUName, + oldADUname, thisTUFZSizing.ZoneNum > 0 ? state.dataHeatBal->Zone(thisTUFZSizing.ZoneNum).Name : "N/A"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermMinFlow, - thisTUFZSizing.ADUName, + oldADUname, thisTUFZSizing.DesCoolVolFlowMin); // ? there is another name that looks similar (see the next line) - OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchAirTermMinOutdoorFlow, thisTUFZSizing.ADUName, thisTUFZSizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermMinOutdoorFlow, oldADUname, thisTUFZSizing.MinOA); - OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchAirTermSupCoolingSP, thisTUFZSizing.ADUName, thisTUFZSizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermSupCoolingSP, oldADUname, thisTUFZSizing.CoolDesTemp); - OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchAirTermSupHeatingSP, thisTUFZSizing.ADUName, thisTUFZSizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermSupHeatingSP, oldADUname, thisTUFZSizing.HeatDesTemp); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermHeatingCap, - thisTUFZSizing.ADUName, + oldADUname, thisTUFZSizing.DesHeatLoad); // ? DesHeatLoad ==? Heating capacity? OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermCoolingCap, - thisTUFZSizing.ADUName, + oldADUname, thisTUFZSizing.DesCoolLoad); // ? DesCoolLoad ==? Cooling capacity? // end std 229 air terminal new table } diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 6e4db3b59c2..371089de500 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -895,6 +895,8 @@ void InitEnergyReports(EnergyPlusData &state) reportZoneEquipmentToplogy(state); + reportAirDistributionUnits(state); + state.dataSysRpts->OneTimeFlag_InitEnergyReports = false; } @@ -5019,6 +5021,56 @@ void fillZoneEquipToplogyComponentRow( ++rowCounter; } +void reportAirDistributionUnits(EnergyPlusData &state) +{ + auto &orp = state.dataOutRptPredefined; + for (auto &adu : state.dataDefineEquipment->AirDistUnit) + { + auto &at = adu.airTerminalPtr; + const int aduCompNum = 1; + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTempCntl, adu.Name, adu.EquipName(aduCompNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, adu.EquipType(aduCompNum)); + + if (adu.TermUnitSizingNum > 0) { + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchAirTermMinFlow, adu.Name, state.dataSize->TermUnitSizing(adu.TermUnitSizingNum).AirVolFlow); + } + + switch (adu.EquipTypeEnum(aduCompNum)) { + case DataDefineEquip::ZnAirLoopEquipType::DualDuctConstVolume: + case DataDefineEquip::ZnAirLoopEquipType::DualDuctVAV: + case DataDefineEquip::ZnAirLoopEquipType::DualDuctVAVOutdoorAir: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolNoReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVNoReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheatVSFan: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ParallelPIU_Reheat: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ConstVol_4PipeInduc: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolCooledBeam: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: + break; + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVNoReheat: + break; + default: + break; + } // end switch + + + } +} + // End of Reporting subroutines for the SimAir Module // ***************************************************************************** diff --git a/src/EnergyPlus/SystemReports.hh b/src/EnergyPlus/SystemReports.hh index 1a1a0832f04..dc3d2c90bda 100644 --- a/src/EnergyPlus/SystemReports.hh +++ b/src/EnergyPlus/SystemReports.hh @@ -345,6 +345,8 @@ namespace SystemReports { void fillZoneEquipToplogyComponentRow( EnergyPlusData &state, const std::string_view &zoneName, const std::string_view &compType, const std::string_view &compName, int &rowCounter); + void reportAirDistributionUnits(EnergyPlusData &state); + // End of Reporting subroutines for the SimAir Module // ***************************************************************************** From f1d2a88c739147c78018434f0b41fdde9ed899c8 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Wed, 28 Feb 2024 16:28:42 -0600 Subject: [PATCH 021/115] Add existing reporting to single duct air terminal case --- src/EnergyPlus/SingleDuct.cc | 41 ++++++++++++++++++++++++++------- src/EnergyPlus/SystemReports.cc | 16 ++++++------- 2 files changed, 41 insertions(+), 16 deletions(-) diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 4cdef6902aa..2ddaaef10ad 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -6514,16 +6514,41 @@ void SingleDuctAirTerminal::CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state) void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) { - // calculates zone outdoor air volume flow rate using the supply air flow rate and OA fraction - if (this->AirLoopNum > 0) { - this->OutdoorAirFlowRate = - (this->sd_airterminalOutlet.AirMassFlowRate / state.dataEnvrn->StdRhoAir) * state.dataAirLoop->AirLoopFlow(this->AirLoopNum).OAFrac; - } else { - this->OutdoorAirFlowRate = 0.0; - } + // populate the predefined equipment summary report related to air terminals + + // xs->pdstAirTerm = newPreDefSubTable(state, s->pdrEquip, "Air Terminals"); + // xs->pdchAirTermZoneName = newPreDefColumn(state, s->pdstAirTerm, "Zone Name"); + // xs->pdchAirTermMinFlow = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow [m3/s]"); + // xs->pdchAirTermMinOutdoorFlow = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow [m3/s]"); + // xs->pdchAirTermSupCoolingSP = newPreDefColumn(state, s->pdstAirTerm, "Supply Cooling Setpoint [C]"); + // xs->pdchAirTermSupHeatingSP = newPreDefColumn(state, s->pdstAirTerm, "Supply Heating Setpoint [C]"); + // xs->pdchAirTermHeatingCap = newPreDefColumn(state, s->pdstAirTerm, "Heating Capacity [W]"); + // xs->pdchAirTermCoolingCap = newPreDefColumn(state, s->pdstAirTerm, "Cooling Capacity [W]"); + // xs->pdchAirTermTypeInp = newPreDefColumn(state, s->pdstAirTerm, "Type of Input Object"); + // s->pdchAirTermHeatCoilType = newPreDefColumn(state, s->pdstAirTerm, "Heat/Reheat Coil Object Type"); + // s->pdchAirTermCoolCoilType = newPreDefColumn(state, s->pdstAirTerm, "Chilled Water Coil Object Type"); + // s->pdchAirTermFanType = newPreDefColumn(state, s->pdstAirTerm, "Fan Object Type"); + // s->pdchAirTermFanName = newPreDefColumn(state, s->pdstAirTerm, "Fan Name"); + // s->pdchAirTermPrimFlow = newPreDefColumn(state, s->pdstAirTerm, "Primary Air Flow Rate [m3/s]"); + // s->pdchAirTermSecdFlow = newPreDefColumn(state, s->pdstAirTerm, "Secondary Air Flow Rate [m3/s]"); + // s->pdchAirTermMinFlowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow Schedule Name"); + // s->pdchAirTermMaxFlowReh = newPreDefColumn(state, s->pdstAirTerm, "Maximum Flow During Reheat [m3/s]"); + // s->pdchAirTermMinOAflowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow Schedule Name"); + // s->pdchAirTermTempCntl = newPreDefColumn(state, s->pdstAirTerm, "Temperature Control"); + + auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->sysType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); } - // End of Reporting subroutines for the Sys Module // ***************************************************************************** diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 371089de500..91bd03458e2 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -5023,20 +5023,21 @@ void fillZoneEquipToplogyComponentRow( void reportAirDistributionUnits(EnergyPlusData &state) { + // populate the predefined tabular report for Equipment Summary - Air Terminals + auto &orp = state.dataOutRptPredefined; - for (auto &adu : state.dataDefineEquipment->AirDistUnit) - { + for (auto &adu : state.dataDefineEquipment->AirDistUnit) { auto &at = adu.airTerminalPtr; const int aduCompNum = 1; OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTempCntl, adu.Name, adu.EquipName(aduCompNum)); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, adu.EquipType(aduCompNum)); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); + // OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, adu.EquipType(aduCompNum)); if (adu.TermUnitSizingNum > 0) { OutputReportPredefined::PreDefTableEntry( - state, orp->pdchAirTermMinFlow, adu.Name, state.dataSize->TermUnitSizing(adu.TermUnitSizingNum).AirVolFlow); + state, orp->pdchAirTermPrimFlow, adu.Name, state.dataSize->TermUnitSizing(adu.TermUnitSizingNum).AirVolFlow); } + auto &sd = state.dataSingleDuct->sd_airterminal(adu.EquipIndex(aduCompNum)); switch (adu.EquipTypeEnum(aduCompNum)) { case DataDefineEquip::ZnAirLoopEquipType::DualDuctConstVolume: @@ -5048,6 +5049,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVNoReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheatVSFan: + sd.reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ParallelPIU_Reheat: @@ -5066,8 +5068,6 @@ void reportAirDistributionUnits(EnergyPlusData &state) default: break; } // end switch - - } } From cd77cf5965ff202f978808e4cc2f2a3b45a71498 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 29 Feb 2024 13:05:07 -0600 Subject: [PATCH 022/115] Finish up the singleduct portion of the EquipmentSummary AirTerminal table. --- src/EnergyPlus/OutputReportPredefined.cc | 1 - src/EnergyPlus/SingleDuct.cc | 40 +++++++++++------------- src/EnergyPlus/SystemReports.cc | 11 +------ 3 files changed, 20 insertions(+), 32 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index aa2934a74c6..a0ffdf24ce5 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -542,7 +542,6 @@ namespace OutputReportPredefined { s->pdchAirTermMinFlowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow Schedule Name"); s->pdchAirTermMaxFlowReh = newPreDefColumn(state, s->pdstAirTerm, "Maximum Flow During Reheat [m3/s]"); s->pdchAirTermMinOAflowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow Schedule Name"); - s->pdchAirTermTempCntl = newPreDefColumn(state, s->pdstAirTerm, "Temperature Control"); // Std 229 Air Heat Recovery s->pdstAirHR = newPreDefSubTable(state, s->pdrEquip, "Air Heat Recovery"); diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 2ddaaef10ad..0efe889b5c7 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -6515,27 +6515,6 @@ void SingleDuctAirTerminal::CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state) void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) { // populate the predefined equipment summary report related to air terminals - - // xs->pdstAirTerm = newPreDefSubTable(state, s->pdrEquip, "Air Terminals"); - // xs->pdchAirTermZoneName = newPreDefColumn(state, s->pdstAirTerm, "Zone Name"); - // xs->pdchAirTermMinFlow = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow [m3/s]"); - // xs->pdchAirTermMinOutdoorFlow = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow [m3/s]"); - // xs->pdchAirTermSupCoolingSP = newPreDefColumn(state, s->pdstAirTerm, "Supply Cooling Setpoint [C]"); - // xs->pdchAirTermSupHeatingSP = newPreDefColumn(state, s->pdstAirTerm, "Supply Heating Setpoint [C]"); - // xs->pdchAirTermHeatingCap = newPreDefColumn(state, s->pdstAirTerm, "Heating Capacity [W]"); - // xs->pdchAirTermCoolingCap = newPreDefColumn(state, s->pdstAirTerm, "Cooling Capacity [W]"); - // xs->pdchAirTermTypeInp = newPreDefColumn(state, s->pdstAirTerm, "Type of Input Object"); - // s->pdchAirTermHeatCoilType = newPreDefColumn(state, s->pdstAirTerm, "Heat/Reheat Coil Object Type"); - // s->pdchAirTermCoolCoilType = newPreDefColumn(state, s->pdstAirTerm, "Chilled Water Coil Object Type"); - // s->pdchAirTermFanType = newPreDefColumn(state, s->pdstAirTerm, "Fan Object Type"); - // s->pdchAirTermFanName = newPreDefColumn(state, s->pdstAirTerm, "Fan Name"); - // s->pdchAirTermPrimFlow = newPreDefColumn(state, s->pdstAirTerm, "Primary Air Flow Rate [m3/s]"); - // s->pdchAirTermSecdFlow = newPreDefColumn(state, s->pdstAirTerm, "Secondary Air Flow Rate [m3/s]"); - // s->pdchAirTermMinFlowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Flow Schedule Name"); - // s->pdchAirTermMaxFlowReh = newPreDefColumn(state, s->pdstAirTerm, "Maximum Flow During Reheat [m3/s]"); - // s->pdchAirTermMinOAflowSch = newPreDefColumn(state, s->pdstAirTerm, "Minimum Outdoor Flow Schedule Name"); - // s->pdchAirTermTempCntl = newPreDefColumn(state, s->pdstAirTerm, "Temperature Control"); - auto &orp = state.dataOutRptPredefined; auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); @@ -6547,6 +6526,25 @@ void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxAirVolFlowRate); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, "n/a"); + if (this->ZoneMinAirFracSchPtr > 0) { + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchAirTermMinFlowSch, adu.Name, ScheduleManager::GetScheduleName(state, this->ZoneMinAirFracSchPtr)); + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, this->MaxAirVolFlowRateDuringReheat); + std::string schName = "n/a"; + if (this->OARequirementsPtr > 0) { + int minOAsch = state.dataSize->OARequirements(this->OARequirementsPtr).OAFlowFracSchPtr; + if (minOAsch > 0) schName = ScheduleManager::GetScheduleName(state, minOAsch); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, schName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->ReheatComp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, this->FanType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } // End of Reporting subroutines for the Sys Module diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 91bd03458e2..455435bb9b8 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -5029,16 +5029,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) for (auto &adu : state.dataDefineEquipment->AirDistUnit) { auto &at = adu.airTerminalPtr; const int aduCompNum = 1; - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTempCntl, adu.Name, adu.EquipName(aduCompNum)); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); - // OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, adu.EquipType(aduCompNum)); - - if (adu.TermUnitSizingNum > 0) { - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchAirTermPrimFlow, adu.Name, state.dataSize->TermUnitSizing(adu.TermUnitSizingNum).AirVolFlow); - } - auto &sd = state.dataSingleDuct->sd_airterminal(adu.EquipIndex(aduCompNum)); - switch (adu.EquipTypeEnum(aduCompNum)) { case DataDefineEquip::ZnAirLoopEquipType::DualDuctConstVolume: case DataDefineEquip::ZnAirLoopEquipType::DualDuctVAV: @@ -5049,7 +5040,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVNoReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheatVSFan: - sd.reportTerminalUnit(state); + state.dataSingleDuct->sd_airterminal(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ParallelPIU_Reheat: From 408049318e549f9097c284911ebe819d6f202092 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 29 Feb 2024 16:41:26 -0600 Subject: [PATCH 023/115] Add support for dual duct systems in equipment summary airterminal report --- src/EnergyPlus/DualDuct.cc | 38 +++++++++++++++++++++++++++++++++ src/EnergyPlus/DualDuct.hh | 5 +++++ src/EnergyPlus/SingleDuct.cc | 17 ++++++++------- src/EnergyPlus/SystemReports.cc | 2 ++ 4 files changed, 54 insertions(+), 8 deletions(-) diff --git a/src/EnergyPlus/DualDuct.cc b/src/EnergyPlus/DualDuct.cc index c9312e66973..963cce6a692 100644 --- a/src/EnergyPlus/DualDuct.cc +++ b/src/EnergyPlus/DualDuct.cc @@ -74,6 +74,7 @@ #include #include #include +#include #include #include #include @@ -2034,6 +2035,43 @@ namespace DualDuct { } } + void DualDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) + { + // populate the predefined equipment summary report related to air terminals + auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } + + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, dualDuctDamperNames[(int)this->DamperType]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxAirVolFlowRate); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, "n/a"); + if (this->ZoneTurndownMinAirFracSchPtr > 0) { + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchAirTermMinFlowSch, adu.Name, ScheduleManager::GetScheduleName(state, this->ZoneTurndownMinAirFracSchPtr)); + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a"); + std::string schName = "n/a"; + if (this->OARequirementsPtr > 0) { + int minOAsch = state.dataSize->OARequirements(this->OARequirementsPtr).OAFlowFracSchPtr; + if (minOAsch > 0) schName = ScheduleManager::GetScheduleName(state, minOAsch); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, schName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "n/a"); + } + } // namespace DualDuct } // namespace EnergyPlus diff --git a/src/EnergyPlus/DualDuct.hh b/src/EnergyPlus/DualDuct.hh index fa9666e51a2..9e097c0e1b2 100644 --- a/src/EnergyPlus/DualDuct.hh +++ b/src/EnergyPlus/DualDuct.hh @@ -73,6 +73,9 @@ namespace DualDuct { Num }; + static constexpr std::array(DualDuctDamper::Num)> dualDuctDamperNames = { + "ConstantVolume", "VariableVolume", "OutdoorAir"}; + enum class PerPersonMode { Invalid = -1, @@ -163,6 +166,8 @@ namespace DualDuct { void CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state); void UpdateDualDuct(EnergyPlusData &state); + + void reportTerminalUnit(EnergyPlusData &state); }; void SimulateDualDuct(EnergyPlusData &state, std::string_view CompName, bool FirstHVACIteration, int ZoneNum, int ZoneNodeNum, int &CompIndex); diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 0efe889b5c7..4462230b41d 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -6517,15 +6517,16 @@ void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) // populate the predefined equipment summary report related to air terminals auto &orp = state.dataOutRptPredefined; auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); - auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); - + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->sysType); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxAirVolFlowRate); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, "n/a"); if (this->ZoneMinAirFracSchPtr > 0) { diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 455435bb9b8..c9594e2c83a 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -70,6 +70,7 @@ #include #include #include +#include #include #include #include @@ -5034,6 +5035,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) case DataDefineEquip::ZnAirLoopEquipType::DualDuctConstVolume: case DataDefineEquip::ZnAirLoopEquipType::DualDuctVAV: case DataDefineEquip::ZnAirLoopEquipType::DualDuctVAVOutdoorAir: + state.dataDualDuct->dd_airterminal(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolNoReheat: From 1c00684f187faa366c15931263da07244239ba65 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 29 Feb 2024 17:19:11 -0600 Subject: [PATCH 024/115] Initial support for PIU in Equipment Summary - Air Terminal report --- src/EnergyPlus/PoweredInductionUnits.cc | 28 +++++++++++++++++++++++++ src/EnergyPlus/PoweredInductionUnits.hh | 2 ++ src/EnergyPlus/SystemReports.cc | 2 ++ 3 files changed, 32 insertions(+) diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 06d85ef9aae..95b17da86c6 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -77,6 +77,7 @@ #include #include #include +#include #include #include #include @@ -2164,4 +2165,31 @@ void PowIndUnitData::CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state) } } +void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) +{ + // populate the predefined equipment summary report related to air terminals + auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->UnitType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxPriAirVolFlow); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, this->MaxSecAirVolFlow); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "x"); +} + + } // namespace EnergyPlus::PoweredInductionUnits diff --git a/src/EnergyPlus/PoweredInductionUnits.hh b/src/EnergyPlus/PoweredInductionUnits.hh index 17864229955..332d8453fc6 100644 --- a/src/EnergyPlus/PoweredInductionUnits.hh +++ b/src/EnergyPlus/PoweredInductionUnits.hh @@ -163,6 +163,8 @@ namespace PoweredInductionUnits { } void CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state); + + void reportTerminalUnit(EnergyPlusData &state); }; void SimPIU(EnergyPlusData &state, diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index c9594e2c83a..c6ecead0675 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -80,6 +80,7 @@ #include #include #include +#include #include #include #include @@ -5046,6 +5047,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ParallelPIU_Reheat: + state.dataPowerInductionUnits->PIU(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ConstVol_4PipeInduc: break; From 35a554bd4d70fc91359db3dcc42925e16c1cd7f9 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 1 Mar 2024 10:33:01 -0600 Subject: [PATCH 025/115] Finished up PIU and did FourPipeInduction report for air terminals --- src/EnergyPlus/HVACSingleDuctInduc.cc | 27 +++++++++++++++++++++++++ src/EnergyPlus/HVACSingleDuctInduc.hh | 1 + src/EnergyPlus/PoweredInductionUnits.cc | 14 ++++++------- src/EnergyPlus/SystemReports.cc | 10 +++++---- 4 files changed, 41 insertions(+), 11 deletions(-) diff --git a/src/EnergyPlus/HVACSingleDuctInduc.cc b/src/EnergyPlus/HVACSingleDuctInduc.cc index d955d2b01b7..8e45bd778b4 100644 --- a/src/EnergyPlus/HVACSingleDuctInduc.cc +++ b/src/EnergyPlus/HVACSingleDuctInduc.cc @@ -71,6 +71,7 @@ #include #include #include +#include #include #include #include @@ -1390,6 +1391,32 @@ namespace HVACSingleDuctInduc { } } + void IndUnitData::reportTerminalUnit(EnergyPlusData &state) + { + // populate the predefined equipment summary report related to air terminals + auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->UnitType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxPriAirMassFlow); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, this->MaxSecAirMassFlow); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->HCoilType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, this->CCoilType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "n/a"); + } + } // namespace HVACSingleDuctInduc } // namespace EnergyPlus diff --git a/src/EnergyPlus/HVACSingleDuctInduc.hh b/src/EnergyPlus/HVACSingleDuctInduc.hh index 94bd5c9877b..5b6db2c132d 100644 --- a/src/EnergyPlus/HVACSingleDuctInduc.hh +++ b/src/EnergyPlus/HVACSingleDuctInduc.hh @@ -139,6 +139,7 @@ namespace HVACSingleDuctInduc { } void ReportIndUnit(EnergyPlusData &state); void CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state); + void reportTerminalUnit(EnergyPlusData &state); }; void SimIndUnit(EnergyPlusData &state, diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 95b17da86c6..70de65b290d 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -2182,13 +2182,13 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->UnitType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxPriAirVolFlow); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, this->MaxSecAirVolFlow); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "x"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "x"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HCoilNamesUC[(int)this->HCoilType]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNamesUC[(int)this->Fan_Num]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index c6ecead0675..538558821e2 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -72,6 +72,7 @@ #include #include #include +#include #include #include #include @@ -5043,6 +5044,8 @@ void reportAirDistributionUnits(EnergyPlusData &state) case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVNoReheat: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctVAVReheatVSFan: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVNoReheat: state.dataSingleDuct->sd_airterminal(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat: @@ -5050,15 +5053,14 @@ void reportAirDistributionUnits(EnergyPlusData &state) state.dataPowerInductionUnits->PIU(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuct_ConstVol_4PipeInduc: + state.dataHVACSingleDuctInduc->IndUnit(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolCooledBeam: - case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: - case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: break; - case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVReheat: - case DataDefineEquip::ZnAirLoopEquipType::SingleDuctCBVAVNoReheat: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: + case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: break; default: break; From c63e10fe8db0814f65fea04f48fbb111fd4f5b37 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 1 Mar 2024 13:14:51 -0600 Subject: [PATCH 026/115] Add cooledbeam to equipment summary air terminal table --- src/EnergyPlus/HVACCooledBeam.cc | 27 +++++++++++++++++++++++++++ src/EnergyPlus/HVACCooledBeam.hh | 1 + src/EnergyPlus/SystemReports.cc | 2 ++ 3 files changed, 30 insertions(+) diff --git a/src/EnergyPlus/HVACCooledBeam.cc b/src/EnergyPlus/HVACCooledBeam.cc index 694f5a58429..5008ead07b2 100644 --- a/src/EnergyPlus/HVACCooledBeam.cc +++ b/src/EnergyPlus/HVACCooledBeam.cc @@ -71,6 +71,7 @@ #include #include #include +#include #include #include #include @@ -1238,6 +1239,32 @@ namespace HVACCooledBeam { } } + void CoolBeamData::reportTerminalUnit(EnergyPlusData &state) + { + // populate the predefined equipment summary report related to air terminals + auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(this->ADUNum); + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, this->UnitType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->MaxAirVolFlow); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, this->CBTypeString); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "n/a"); + } + } // namespace HVACCooledBeam } // namespace EnergyPlus diff --git a/src/EnergyPlus/HVACCooledBeam.hh b/src/EnergyPlus/HVACCooledBeam.hh index 8c3e389bb0d..f9157b510db 100644 --- a/src/EnergyPlus/HVACCooledBeam.hh +++ b/src/EnergyPlus/HVACCooledBeam.hh @@ -143,6 +143,7 @@ namespace HVACCooledBeam { } void CalcOutdoorAirVolumeFlowRate(EnergyPlusData &state); + void reportTerminalUnit(EnergyPlusData &state); }; void SimCoolBeam(EnergyPlusData &state, diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 538558821e2..48d03a7b469 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -72,6 +72,7 @@ #include #include #include +#include #include #include #include @@ -5056,6 +5057,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) state.dataHVACSingleDuctInduc->IndUnit(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolCooledBeam: + state.dataHVACCooledBeam->CoolBeam(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: break; From aa69233f949df1df0fc29bdd687ede6e3105788e Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 1 Mar 2024 15:38:07 -0600 Subject: [PATCH 027/115] Add four pipe beam to equipment summary air terminal report --- src/EnergyPlus/HVACFourPipeBeam.cc | 35 ++++++++++++++++++++++++++++++ src/EnergyPlus/HVACFourPipeBeam.hh | 2 ++ src/EnergyPlus/SystemReports.cc | 2 ++ 3 files changed, 39 insertions(+) diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index b6d911f97a1..3edd6c34295 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -74,6 +74,7 @@ #include #include #include +#include #include #include #include @@ -1440,6 +1441,40 @@ namespace FourPipeBeam { } } + void HVACFourPipeBeam::reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu) + { + // populate the predefined equipment summary report related to air terminals + auto &orp = state.dataOutRptPredefined; + if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { + auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOutdoorFlow, adu.Name, sizing.MinOA); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupCoolingSP, adu.Name, sizing.CoolDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSupHeatingSP, adu.Name, sizing.HeatDesTemp); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatingCap, adu.Name, sizing.DesHeatLoad); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolingCap, adu.Name, sizing.DesCoolLoad); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermTypeInp, adu.Name, "AirTerminal:SingleDuct:ConstantVolume:FourPipeBeam"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermPrimFlow, adu.Name, this->vDotNormRatedPrimAir); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermSecdFlow, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); + if (this->beamHeatingPresent) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "Included"); + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, "None"); + } + + if (this->beamCoolingPresent) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "Included"); + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "None"); + } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "n/a"); + } + } // namespace FourPipeBeam } // namespace EnergyPlus diff --git a/src/EnergyPlus/HVACFourPipeBeam.hh b/src/EnergyPlus/HVACFourPipeBeam.hh index c8b6c537e11..242d3853250 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.hh +++ b/src/EnergyPlus/HVACFourPipeBeam.hh @@ -113,6 +113,8 @@ namespace FourPipeBeam { int getTermUnitSizingIndex(); + void reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu); + private: // Methods void init(EnergyPlusData &state, diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 48d03a7b469..87a23ca49d0 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -73,6 +73,7 @@ #include #include #include +#include #include #include #include @@ -5060,6 +5061,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) state.dataHVACCooledBeam->CoolBeam(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: + state.dataFourPipeBeam->FourPipeBeams(adu.EquipIndex(aduCompNum))->reportTerminalUnit(state, adu); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: From d533984c29264d06bad5a269d7c06dae8cecc39e Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 1 Mar 2024 17:22:44 -0600 Subject: [PATCH 028/115] Begin adding support for four pipe beam for air terminal report - not compiling --- src/EnergyPlus/HVACFourPipeBeam.cc | 3 ++- src/EnergyPlus/HVACFourPipeBeam.hh | 7 ++++++- src/EnergyPlus/SystemReports.cc | 6 ++++-- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index 3edd6c34295..0bfbb2e1596 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -1441,10 +1441,11 @@ namespace FourPipeBeam { } } - void HVACFourPipeBeam::reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu) + void HVACFourPipeBeam::reportTerminalUnit(EnergyPlusData &state) { // populate the predefined equipment summary report related to air terminals auto &orp = state.dataOutRptPredefined; + auto &adu = state.dataDefineEquipment->AirDistUnit(1); if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); diff --git a/src/EnergyPlus/HVACFourPipeBeam.hh b/src/EnergyPlus/HVACFourPipeBeam.hh index 242d3853250..0401bbb86a5 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.hh +++ b/src/EnergyPlus/HVACFourPipeBeam.hh @@ -113,7 +113,12 @@ namespace FourPipeBeam { int getTermUnitSizingIndex(); - void reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu); + void reportTerminalUnit(EnergyPlusData &state); + + // void reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu); + // void reportTerminalUnit(EnergyPlusData &state, int aduNumber); + // void reportTerminalUnit(EnergyPlusData &state); + private: // Methods void diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 87a23ca49d0..4d61f823e01 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -5032,7 +5032,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) auto &orp = state.dataOutRptPredefined; for (auto &adu : state.dataDefineEquipment->AirDistUnit) { - auto &at = adu.airTerminalPtr; + auto &airTerminal = adu.airTerminalPtr; const int aduCompNum = 1; OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); switch (adu.EquipTypeEnum(aduCompNum)) { @@ -5061,7 +5061,9 @@ void reportAirDistributionUnits(EnergyPlusData &state) state.dataHVACCooledBeam->CoolBeam(adu.EquipIndex(aduCompNum)).reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: - state.dataFourPipeBeam->FourPipeBeams(adu.EquipIndex(aduCompNum))->reportTerminalUnit(state, adu); + adu.airTerminalPtr->reportTerminalUnit(state); + // state.dataFourPipeBeam->FourPipeBeams(adu.EquipIndex(aduCompNum))->reportTerminalUnit(state); + // state.dataFourPipeBeam->FourPipeBeams(1)->reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: From b2f6212c89b7d6b78c2deebcf25aa88e9422a464 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 4 Mar 2024 13:23:58 -0600 Subject: [PATCH 029/115] Finish up four pipe beam reporting for air terminals --- src/EnergyPlus/AirTerminalUnit.hh | 2 ++ src/EnergyPlus/HVACFourPipeBeam.cc | 2 +- src/EnergyPlus/HVACFourPipeBeam.hh | 5 ----- src/EnergyPlus/SystemReports.cc | 2 -- 4 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/EnergyPlus/AirTerminalUnit.hh b/src/EnergyPlus/AirTerminalUnit.hh index 34e6ed80d7f..9574686c6fa 100644 --- a/src/EnergyPlus/AirTerminalUnit.hh +++ b/src/EnergyPlus/AirTerminalUnit.hh @@ -101,6 +101,8 @@ public: // Methods virtual int getTermUnitSizingIndex() = 0; + virtual void reportTerminalUnit(EnergyPlusData &state) = 0; + protected: // Data AirTerminalUnitType terminalType = notYetDetermined; // Type of air distribution unit //Legacy For use during transition to OO std::string name; // name of unit diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index 0bfbb2e1596..fbec9c3d3df 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -1445,7 +1445,7 @@ namespace FourPipeBeam { { // populate the predefined equipment summary report related to air terminals auto &orp = state.dataOutRptPredefined; - auto &adu = state.dataDefineEquipment->AirDistUnit(1); + auto &adu = state.dataDefineEquipment->AirDistUnit(this->aDUNum); if (!state.dataSize->TermUnitFinalZoneSizing.empty()) { auto &sizing = state.dataSize->TermUnitFinalZoneSizing(adu.TermUnitSizingNum); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlow, adu.Name, sizing.DesCoolVolFlowMin); diff --git a/src/EnergyPlus/HVACFourPipeBeam.hh b/src/EnergyPlus/HVACFourPipeBeam.hh index 0401bbb86a5..f52a49a80b1 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.hh +++ b/src/EnergyPlus/HVACFourPipeBeam.hh @@ -115,11 +115,6 @@ namespace FourPipeBeam { void reportTerminalUnit(EnergyPlusData &state); - // void reportTerminalUnit(EnergyPlusData &state, DataDefineEquip::ZoneAirEquip &adu); - // void reportTerminalUnit(EnergyPlusData &state, int aduNumber); - // void reportTerminalUnit(EnergyPlusData &state); - - private: // Methods void init(EnergyPlusData &state, diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 4d61f823e01..8937018b5cf 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -5062,8 +5062,6 @@ void reportAirDistributionUnits(EnergyPlusData &state) break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctConstVolFourPipeBeam: adu.airTerminalPtr->reportTerminalUnit(state); - // state.dataFourPipeBeam->FourPipeBeams(adu.EquipIndex(aduCompNum))->reportTerminalUnit(state); - // state.dataFourPipeBeam->FourPipeBeams(1)->reportTerminalUnit(state); break; case DataDefineEquip::ZnAirLoopEquipType::SingleDuctUserDefined: case DataDefineEquip::ZnAirLoopEquipType::SingleDuctATMixer: From ed884ce48cb50e148f08cc0f57be3169a7dc84de Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 4 Mar 2024 15:13:34 -0600 Subject: [PATCH 030/115] Get rid of old sizing based reporting for airterminals. Clean ups for CI. --- src/EnergyPlus/PoweredInductionUnits.cc | 1 - src/EnergyPlus/SizingManager.cc | 28 ------------------------- src/EnergyPlus/SystemReports.cc | 2 +- 3 files changed, 1 insertion(+), 30 deletions(-) diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 70de65b290d..1e16f1e9fe4 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -2191,5 +2191,4 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } - } // namespace EnergyPlus::PoweredInductionUnits diff --git a/src/EnergyPlus/SizingManager.cc b/src/EnergyPlus/SizingManager.cc index ad51b9bd1e1..31be55cb933 100644 --- a/src/EnergyPlus/SizingManager.cc +++ b/src/EnergyPlus/SizingManager.cc @@ -5507,34 +5507,6 @@ void UpdateTermUnitFinalZoneSizing(EnergyPlusData &state) thisTUFZSizing.DesHeatOAFlowFrac = 0.0; } } - - // begin std 229 air terminal new table - std::string oldADUname = format("{}-old", thisTUFZSizing.ADUName); - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchAirTermZoneName, - oldADUname, - thisTUFZSizing.ZoneNum > 0 ? state.dataHeatBal->Zone(thisTUFZSizing.ZoneNum).Name : "N/A"); - - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchAirTermMinFlow, - oldADUname, - thisTUFZSizing.DesCoolVolFlowMin); // ? there is another name that looks similar (see the next line) - - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermMinOutdoorFlow, oldADUname, thisTUFZSizing.MinOA); - - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermSupCoolingSP, oldADUname, thisTUFZSizing.CoolDesTemp); - - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirTermSupHeatingSP, oldADUname, thisTUFZSizing.HeatDesTemp); - - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchAirTermHeatingCap, - oldADUname, - thisTUFZSizing.DesHeatLoad); // ? DesHeatLoad ==? Heating capacity? - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchAirTermCoolingCap, - oldADUname, - thisTUFZSizing.DesCoolLoad); // ? DesCoolLoad ==? Cooling capacity? - // end std 229 air terminal new table } } } // namespace EnergyPlus::SizingManager diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 8937018b5cf..e6a57528325 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -5033,7 +5033,7 @@ void reportAirDistributionUnits(EnergyPlusData &state) auto &orp = state.dataOutRptPredefined; for (auto &adu : state.dataDefineEquipment->AirDistUnit) { auto &airTerminal = adu.airTerminalPtr; - const int aduCompNum = 1; + constexpr int aduCompNum = 1; OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermZoneName, adu.Name, state.dataHeatBal->Zone(adu.ZoneNum).Name); switch (adu.EquipTypeEnum(aduCompNum)) { case DataDefineEquip::ZnAirLoopEquipType::DualDuctConstVolume: From e9d42ae172d3d85ad93e920fd24c199a3c27e48a Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 25 Mar 2024 11:59:47 -0500 Subject: [PATCH 031/115] Add zone and adjacent surface for envelope summary opaque interior and zone for opaque exterior --- src/EnergyPlus/HeatBalanceSurfaceManager.cc | 3 +++ src/EnergyPlus/OutputReportPredefined.cc | 3 +++ src/EnergyPlus/OutputReportPredefined.hh | 3 +++ 3 files changed, 9 insertions(+) diff --git a/src/EnergyPlus/HeatBalanceSurfaceManager.cc b/src/EnergyPlus/HeatBalanceSurfaceManager.cc index 0952daf924a..bc28e966ba5 100644 --- a/src/EnergyPlus/HeatBalanceSurfaceManager.cc +++ b/src/EnergyPlus/HeatBalanceSurfaceManager.cc @@ -754,6 +754,7 @@ void GatherForPredefinedReport(EnergyPlusData &state) auto const &thisZone = state.dataHeatBal->Zone(surface.Zone); mult = thisZone.Multiplier * thisZone.ListMultiplier; OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpCons, surfName, construct.Name); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpZone, surfName, thisZone.Name); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpRefl, surfName, 1 - construct.OutsideAbsorpSolar); OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchOpUfactNoFilm, surfName, state.dataHeatBal->NominalU(surface.Construction), 3); @@ -1039,6 +1040,8 @@ void GatherForPredefinedReport(EnergyPlusData &state) auto const &thisZone = state.dataHeatBal->Zone(surface.Zone); mult = thisZone.Multiplier * thisZone.ListMultiplier; OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpCons, surfName, construct.Name); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpZone, surfName, thisZone.Name); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpAdjSurf, surfName, surface.ExtBoundCondName); OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchIntOpRefl, surfName, 1 - construct.OutsideAbsorpSolar); OutputReportPredefined::PreDefTableEntry( diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index a0ffdf24ce5..5bd28ab3cfe 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -126,6 +126,7 @@ namespace OutputReportPredefined { s->pdstOpaque = newPreDefSubTable(state, s->pdrEnvelope, "Opaque Exterior"); s->pdchOpCons = newPreDefColumn(state, s->pdstOpaque, "Construction"); + s->pdchOpZone = newPreDefColumn(state, s->pdstOpaque, "Zone"); s->pdchOpRefl = newPreDefColumn(state, s->pdstOpaque, "Reflectance"); s->pdchOpUfactFilm = newPreDefColumn(state, s->pdstOpaque, "U-Factor with Film [W/m2-K]"); s->pdchOpUfactNoFilm = newPreDefColumn(state, s->pdstOpaque, "U-Factor no Film [W/m2-K]"); @@ -138,6 +139,8 @@ namespace OutputReportPredefined { s->pdstIntOpaque = newPreDefSubTable(state, s->pdrEnvelope, "Opaque Interior"); s->pdchIntOpCons = newPreDefColumn(state, s->pdstIntOpaque, "Construction"); + s->pdchIntOpZone = newPreDefColumn(state, s->pdstIntOpaque, "Zone"); + s->pdchIntOpAdjSurf = newPreDefColumn(state, s->pdstIntOpaque, "Adjacent Surface"); s->pdchIntOpRefl = newPreDefColumn(state, s->pdstIntOpaque, "Reflectance"); s->pdchIntOpUfactFilm = newPreDefColumn(state, s->pdstIntOpaque, "U-Factor with Film [W/m2-K]"); s->pdchIntOpUfactNoFilm = newPreDefColumn(state, s->pdstIntOpaque, "U-Factor no Film [W/m2-K]"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index b20d8339233..52f16080016 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -482,6 +482,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdrEnvelope = 0; int pdstOpaque = 0; int pdchOpCons = 0; + int pdchOpZone = 0; int pdchOpRefl = 0; int pdchOpUfactFilm = 0; int pdchOpUfactNoFilm = 0; @@ -492,6 +493,8 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchOpDir = 0; int pdstIntOpaque = 0; int pdchIntOpCons = 0; + int pdchIntOpZone = 0; + int pdchIntOpAdjSurf = 0; int pdchIntOpRefl = 0; int pdchIntOpUfactFilm = 0; int pdchIntOpUfactNoFilm = 0; From a5d842e17b98ef2da14be238f7c6b64d2454d93c Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 25 Mar 2024 13:34:08 -0500 Subject: [PATCH 032/115] Add opaque construction layer table to envelope summary report --- src/EnergyPlus/Construction.cc | 13 +++++++++++++ src/EnergyPlus/Construction.hh | 2 ++ src/EnergyPlus/HeatBalanceManager.cc | 5 +++++ src/EnergyPlus/OutputReportPredefined.cc | 13 +++++++++++++ src/EnergyPlus/OutputReportPredefined.hh | 3 +++ 5 files changed, 36 insertions(+) diff --git a/src/EnergyPlus/Construction.cc b/src/EnergyPlus/Construction.cc index 0f20fcd4fba..34606587bab 100644 --- a/src/EnergyPlus/Construction.cc +++ b/src/EnergyPlus/Construction.cc @@ -51,6 +51,7 @@ #include #include #include +#include #include namespace EnergyPlus::Construction { @@ -1919,6 +1920,18 @@ void ConstructionProps::reportTransferFunction(EnergyPlusData &state, int const } } +void ConstructionProps::reportLayers(EnergyPlusData &state) +{ + // Report the layers for each opaque construction in predefined tabular report + // J. Glazer March 2024 + auto &opd = state.dataOutRptPredefined; + for (int i = 1; i <= this->TotLayers; ++i) { + int layerIndex = this->LayerPoint(i); + auto const *thisMaterial = state.dataMaterial->Material(layerIndex); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, thisMaterial->Name); + } +} + bool ConstructionProps::isGlazingConstruction(EnergyPlusData &state) const { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/Construction.hh b/src/EnergyPlus/Construction.hh index a0a56b321ac..5af7236daba 100644 --- a/src/EnergyPlus/Construction.hh +++ b/src/EnergyPlus/Construction.hh @@ -299,6 +299,8 @@ namespace Construction { void reportTransferFunction(EnergyPlusData &state, int cCounter); + void reportLayers(EnergyPlusData &state); + bool isGlazingConstruction(EnergyPlusData &state) const; Real64 setThicknessPerpendicular(EnergyPlusData &state, Real64 userValue); diff --git a/src/EnergyPlus/HeatBalanceManager.cc b/src/EnergyPlus/HeatBalanceManager.cc index 13b728e2a47..9dba6d8cf5e 100644 --- a/src/EnergyPlus/HeatBalanceManager.cc +++ b/src/EnergyPlus/HeatBalanceManager.cc @@ -7116,6 +7116,11 @@ namespace HeatBalanceManager { state.dataHeatBal->SimpleCTFOnly = false; } + for (auto &construction : state.dataConstruction->Construct) { + if (!construction.IsUsedCTF) continue; + construction.reportLayers(state); + } + bool InitCTFDoReport; General::ScanForReports(state, "Constructions", InitCTFDoReport, "Constructions"); if (InitCTFDoReport || DoCTFErrorReport) { diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 5bd28ab3cfe..80cde31d643 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -215,6 +215,19 @@ namespace OutputReportPredefined { s->pdchIntDrGrArea = newPreDefColumn(state, s->pdstIntDoor, "Gross Area [m2]"); s->pdchIntDrParent = newPreDefColumn(state, s->pdstIntDoor, "Parent Surface"); + s->pdstOpqConsLayers = newPreDefSubTable(state, s->pdrEnvelope, "Opaque Construction Layers"); + + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 1")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 2")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 3")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 4")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 5")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 6")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 7")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 8")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 9")); + s->pdchOpqConsLayCol.push_back(newPreDefColumn(state, s->pdstOpqConsLayers, "Layer 10")); + // Shading Report s->pdrShading = newPreDefReport(state, "ShadingSummary", "Shade", "Shading Summary"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 52f16080016..7ce136e3306 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -557,6 +557,9 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchIntFenVisTr = 0; int pdchIntFenParent = 0; + int pdstOpqConsLayers = 0; + std::vector pdchOpqConsLayCol; + // Shading Report int pdrShading = 0; int pdstSunlitFrac = 0; From 5f9c7d5f4ac33530c1650ee6f52dfbee3db40621 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 25 Mar 2024 16:15:56 -0500 Subject: [PATCH 033/115] Protect new function against unit SolarShadingTest_NonConvexErrors unit test. --- src/EnergyPlus/Construction.cc | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/EnergyPlus/Construction.cc b/src/EnergyPlus/Construction.cc index 34606587bab..1e3eaa8df90 100644 --- a/src/EnergyPlus/Construction.cc +++ b/src/EnergyPlus/Construction.cc @@ -1925,10 +1925,12 @@ void ConstructionProps::reportLayers(EnergyPlusData &state) // Report the layers for each opaque construction in predefined tabular report // J. Glazer March 2024 auto &opd = state.dataOutRptPredefined; - for (int i = 1; i <= this->TotLayers; ++i) { - int layerIndex = this->LayerPoint(i); - auto const *thisMaterial = state.dataMaterial->Material(layerIndex); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, thisMaterial->Name); + if (state.dataOutRptPredefined->pdchOpqConsLayCol.size() > 0) { + for (int i = 1; i <= this->TotLayers; ++i) { + int layerIndex = this->LayerPoint(i); + auto const *thisMaterial = state.dataMaterial->Material(layerIndex); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, thisMaterial->Name); + } } } From 41b53d8dcdee19e205846ef3a070862aee4554d1 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 26 Mar 2024 11:40:25 -0500 Subject: [PATCH 034/115] Add Thermostat Schedule table to System Summary report. --- src/EnergyPlus/DataHVACGlobals.hh | 3 ++ src/EnergyPlus/OutputReportPredefined.cc | 8 ++++ src/EnergyPlus/OutputReportPredefined.hh | 8 ++++ src/EnergyPlus/OutputReportTabular.cc | 1 + src/EnergyPlus/ZoneTempPredictorCorrector.cc | 48 ++++++++++++++++++++ src/EnergyPlus/ZoneTempPredictorCorrector.hh | 2 + 6 files changed, 70 insertions(+) diff --git a/src/EnergyPlus/DataHVACGlobals.hh b/src/EnergyPlus/DataHVACGlobals.hh index bc45fd6470f..194031c97df 100644 --- a/src/EnergyPlus/DataHVACGlobals.hh +++ b/src/EnergyPlus/DataHVACGlobals.hh @@ -112,6 +112,9 @@ namespace DataHVACGlobals { Num }; + static constexpr std::array(ThermostatType::Num)> thermostatTypeNames = { + "Uncontrolled", "SingleHeating", "SingleCooling", "SingleHeatCool", "DualSetPointWithDeadBand"}; + enum class AirDuctType // parameters describing air duct type { diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 80cde31d643..a37a991790b 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -925,6 +925,14 @@ namespace OutputReportPredefined { s->pdchULnotMetHeatOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Heating [hr]"); s->pdchULnotMetCoolOcc = newPreDefColumn(state, s->pdstUnmetLoads, "During Occupied Cooling [hr]"); + s->pdstStatSchd = newPreDefSubTable(state, s->pdrSystem, "Thermostat Schedules"); + s->pdchStatName = newPreDefColumn(state, s->pdstStatSchd, "Thermostat Name 1"); + s->pdchStatCtrlTypeSchd = newPreDefColumn(state, s->pdstStatSchd, "Control Type Schedule"); + s->pdchStatSchdType1 = newPreDefColumn(state, s->pdstStatSchd, "Control Type"); + s->pdchStatSchdTypeName1 = newPreDefColumn(state, s->pdstStatSchd, "Control Type Name"); + s->pdchStatSchdHeatName = newPreDefColumn(state, s->pdstStatSchd, "Heating Schedule"); + s->pdchStatSchdCoolName = newPreDefColumn(state, s->pdstStatSchd, "Cooling Schedule"); + // HVAC Topology Report s->pdrTopology = newPreDefReport(state, "HVACTopology", "Top", "HVAC Topology"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 7ce136e3306..6dc77bf928e 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -888,6 +888,14 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchULnotMetHeatOcc = 0; int pdchULnotMetCoolOcc = 0; + int pdstStatSchd = 0; + int pdchStatName = 0; + int pdchStatCtrlTypeSchd = 0; + int pdchStatSchdType1 = 0; + int pdchStatSchdTypeName1 = 0; + int pdchStatSchdHeatName = 0; + int pdchStatSchdCoolName = 0; + // HVAC Topology int pdrTopology = 0; diff --git a/src/EnergyPlus/OutputReportTabular.cc b/src/EnergyPlus/OutputReportTabular.cc index 39bc1d971cd..4a0557dfbc0 100644 --- a/src/EnergyPlus/OutputReportTabular.cc +++ b/src/EnergyPlus/OutputReportTabular.cc @@ -6899,6 +6899,7 @@ void FillRemainingPredefinedEntries(EnergyPlusData &state) } // fill the LEED setpoint table ZoneTempPredictorCorrector::FillPredefinedTableOnThermostatSetpoints(state); + ZoneTempPredictorCorrector::FillPredefinedTableOnThermostatSchedules(state); } void WriteMonthlyTables(EnergyPlusData &state) diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.cc b/src/EnergyPlus/ZoneTempPredictorCorrector.cc index 9b0ee545885..5c17c0d86f5 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.cc +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.cc @@ -7059,6 +7059,54 @@ temperatureAndCountInSch(EnergyPlusData &state, int const scheduleIndex, bool co return std::make_tuple(valueAtSelectTime, countOfSame, monthName); } +void FillPredefinedTableOnThermostatSchedules(EnergyPlusData &state) +{ + // add values to the System Summary tabular report related to schedules used by the thermostat objects + // J.Glazer - March 2024 + using OutputReportPredefined::PreDefTableEntry; + auto &orp = state.dataOutRptPredefined; + for (int idx = 1; idx <= state.dataZoneCtrls->NumTempControlledZones; ++idx) { + auto &tcz = state.dataZoneCtrls->TempControlledZone(idx); + PreDefTableEntry(state, orp->pdchStatName, tcz.ZoneName, tcz.Name); + PreDefTableEntry(state, orp->pdchStatCtrlTypeSchd, tcz.ZoneName, tcz.ControlTypeSchedName); + for (int ctInx = 1; ctInx <= tcz.NumControlTypes; ++ctInx) { + PreDefTableEntry(state, orp->pdchStatSchdType1, + tcz.ZoneName, DataHVACGlobals::thermostatTypeNames[(int)tcz.ControlTypeEnum(ctInx)]); + PreDefTableEntry(state, orp->pdchStatSchdTypeName1, tcz.ZoneName, tcz.ControlTypeName(1)); + switch (tcz.ControlTypeEnum(ctInx)) { + case DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand: + PreDefTableEntry(state, + orp->pdchStatSchdHeatName, + tcz.ZoneName, + ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandHeat)); + PreDefTableEntry(state, + orp->pdchStatSchdCoolName, + tcz.ZoneName, + ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandCool)); + break; + case DataHVACGlobals::ThermostatType::SingleHeatCool: + PreDefTableEntry(state, + orp->pdchStatSchdHeatName, + tcz.ZoneName, + ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); + PreDefTableEntry(state, + orp->pdchStatSchdCoolName, + tcz.ZoneName, + ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); + break; + case DataHVACGlobals::ThermostatType::SingleCooling: + PreDefTableEntry( + state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleCoolSetPoint)); + break; + case DataHVACGlobals::ThermostatType::SingleHeating: + PreDefTableEntry( + state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatSetPoint)); + break; + } + } + } +} + void ZoneSpaceHeatBalanceData::updateTemperatures(EnergyPlusData &state, bool const ShortenTimeStepSys, bool const UseZoneTimeStepHistory, diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.hh b/src/EnergyPlus/ZoneTempPredictorCorrector.hh index 1298b64af32..39c440e3a1b 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.hh +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.hh @@ -379,6 +379,8 @@ namespace ZoneTempPredictorCorrector { void FillPredefinedTableOnThermostatSetpoints(EnergyPlusData &state); + void FillPredefinedTableOnThermostatSchedules(EnergyPlusData &state); + std::tuple temperatureAndCountInSch(EnergyPlusData &state, int scheduleIndex, bool isSummer, int dayOfWeek, int hourOfDay); From de9cf7a624784bc30d518f4bef8ecc7a583b3067 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 26 Mar 2024 12:48:40 -0500 Subject: [PATCH 035/115] Clang format fixes --- src/EnergyPlus/OutputReportPredefined.hh | 2 +- src/EnergyPlus/ZoneTempPredictorCorrector.cc | 53 ++++++++------------ 2 files changed, 23 insertions(+), 32 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 6dc77bf928e..292e4d1b303 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -482,7 +482,7 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdrEnvelope = 0; int pdstOpaque = 0; int pdchOpCons = 0; - int pdchOpZone = 0; + int pdchOpZone = 0; int pdchOpRefl = 0; int pdchOpUfactFilm = 0; int pdchOpUfactNoFilm = 0; diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.cc b/src/EnergyPlus/ZoneTempPredictorCorrector.cc index 5c17c0d86f5..57f743a956b 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.cc +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.cc @@ -7070,39 +7070,30 @@ void FillPredefinedTableOnThermostatSchedules(EnergyPlusData &state) PreDefTableEntry(state, orp->pdchStatName, tcz.ZoneName, tcz.Name); PreDefTableEntry(state, orp->pdchStatCtrlTypeSchd, tcz.ZoneName, tcz.ControlTypeSchedName); for (int ctInx = 1; ctInx <= tcz.NumControlTypes; ++ctInx) { - PreDefTableEntry(state, orp->pdchStatSchdType1, - tcz.ZoneName, DataHVACGlobals::thermostatTypeNames[(int)tcz.ControlTypeEnum(ctInx)]); + PreDefTableEntry(state, orp->pdchStatSchdType1, tcz.ZoneName, DataHVACGlobals::thermostatTypeNames[(int)tcz.ControlTypeEnum(ctInx)]); PreDefTableEntry(state, orp->pdchStatSchdTypeName1, tcz.ZoneName, tcz.ControlTypeName(1)); switch (tcz.ControlTypeEnum(ctInx)) { - case DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand: - PreDefTableEntry(state, - orp->pdchStatSchdHeatName, - tcz.ZoneName, - ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandHeat)); - PreDefTableEntry(state, - orp->pdchStatSchdCoolName, - tcz.ZoneName, - ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandCool)); - break; - case DataHVACGlobals::ThermostatType::SingleHeatCool: - PreDefTableEntry(state, - orp->pdchStatSchdHeatName, - tcz.ZoneName, - ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); - PreDefTableEntry(state, - orp->pdchStatSchdCoolName, - tcz.ZoneName, - ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); - break; - case DataHVACGlobals::ThermostatType::SingleCooling: - PreDefTableEntry( - state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleCoolSetPoint)); - break; - case DataHVACGlobals::ThermostatType::SingleHeating: - PreDefTableEntry( - state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatSetPoint)); - break; - } + case DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand: + PreDefTableEntry( + state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandHeat)); + PreDefTableEntry( + state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandCool)); + break; + case DataHVACGlobals::ThermostatType::SingleHeatCool: + PreDefTableEntry( + state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); + PreDefTableEntry( + state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); + break; + case DataHVACGlobals::ThermostatType::SingleCooling: + PreDefTableEntry( + state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleCoolSetPoint)); + break; + case DataHVACGlobals::ThermostatType::SingleHeating: + PreDefTableEntry( + state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatSetPoint)); + break; + } } } } From d55bc95ec8a5d7d3b580558f087d6cc9e6612fa4 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 26 Mar 2024 17:53:55 -0500 Subject: [PATCH 036/115] Plant Loop Topology improve Splitter/Mixer --- src/EnergyPlus/OutputReportPredefined.cc | 3 +- src/EnergyPlus/OutputReportPredefined.hh | 3 +- src/EnergyPlus/Plant/PlantManager.cc | 93 ++++++++++-------------- src/EnergyPlus/Plant/PlantManager.hh | 11 ++- 4 files changed, 53 insertions(+), 57 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index a0ffdf24ce5..2c9cb9dbf92 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -949,10 +949,11 @@ namespace OutputReportPredefined { s->pdchTopPlantLoopType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Type"); s->pdchTopPlantLoopName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Name"); s->pdchTopPlantSide2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Side"); - s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + s->pdchTopPlantSplitName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter Name"); s->pdchTopPlantBranchName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Branch Name"); s->pdchTopPlantCompType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Type"); s->pdchTopPlantCompName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Name"); + s->pdchTopPlantMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Mixer Name"); // Outdoor Air Report s->pdrOutsideAir = newPreDefReport(state, "OutdoorAirSummary", "OA", "Outdoor Air Summary"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index b20d8339233..7d38e97fa56 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -922,10 +922,11 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopPlantLoopType2 = 0; int pdchTopPlantLoopName2 = 0; int pdchTopPlantSide2 = 0; - int pdchTopPlantSplitMixName2 = 0; + int pdchTopPlantSplitName2 = 0; int pdchTopPlantBranchName2 = 0; int pdchTopPlantCompType2 = 0; int pdchTopPlantCompName2 = 0; + int pdchTopPlantMixName2 = 0; // Outdoor Air Report int pdrOutsideAir = 0; diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 4b5fe262949..99a23272779 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -2095,14 +2095,16 @@ void fillPlantCondenserTopology(EnergyPlusData &state, DataPlant::PlantLoopData auto &thisLoopSide = thisLoop.LoopSide(LoopSideNum); std::string_view const loopSide = DataPlant::DemandSupplyNames[static_cast(LoopSideNum)]; - // OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompType + repOffset, thisLoopSide.loopSideDescription, loopType); - // OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide + repOffset, thisLoopSide.loopSideDescription, loopSide); - - // s->pdstTopPlantLoop2 = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement 2"); + // s->pdstTopPlantLoop2 = newPreDefSubTable(state, s->pdrTopology, "Plant Loop Component Arrangement"); // s->pdchTopPlantLoopType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Type"); // s->pdchTopPlantLoopName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Loop Name"); // s->pdchTopPlantSide2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Side"); - // s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + // s->pdchTopPlantSplitName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter Name"); + // s->pdchTopPlantBranchName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Branch Name"); + // s->pdchTopPlantCompType2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Type"); + // s->pdchTopPlantCompName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Component Name"); + // s->pdchTopPlantMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Mixer Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), thisLoop.Name); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), loopSide); @@ -2111,28 +2113,20 @@ void fillPlantCondenserTopology(EnergyPlusData &state, DataPlant::PlantLoopData // Report for first branch auto &thisBranch = thisLoopSide.Branch(1); constexpr std::string_view branch = "Branch"; - // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); - // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { auto &thisComp = thisBranch.Comp(compNum); - // fillPlantToplogyRow(state, thisComp.Name, thisComp.TypeOf, loopSide, branch, thisBranch.Name, thisLoop.FluidName, repOffset); fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); } if (thisLoopSide.TotalBranches >= 3) { - // splitter - if (thisLoopSide.Splitter.Exists) { - constexpr std::string_view splitter = "Splitter"; - // fillPlantToplogyRow(state, thisLoopSide.Splitter.Name, splitter, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); - fillPlantToplogySplitterMixerRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Splitter.Name, rowCounter); - } - // parallel branches for (int branchNum = 2; branchNum <= thisLoopSide.TotalBranches - 1; ++branchNum) { auto &thisBranch = thisLoopSide.Branch(branchNum); - // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); - // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); + // splitter + if (thisLoopSide.Splitter.Exists) { + fillPlantToplogySplitterRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Splitter.Name, rowCounter); + } for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { auto &thisComp = thisBranch.Comp(compNum); @@ -2140,59 +2134,52 @@ void fillPlantCondenserTopology(EnergyPlusData &state, DataPlant::PlantLoopData fillPlantToplogyComponentRow2( state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); } - } - - // mixer - if (thisLoopSide.Mixer.Exists) { - constexpr std::string_view mixer = "Mixer"; - // fillPlantToplogyRow(state, thisLoopSide.Mixer.Name, mixer, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); - fillPlantToplogySplitterMixerRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Mixer.Name, rowCounter); + // mixer + if (thisLoopSide.Mixer.Exists) { + rowCounter -= 1; + constexpr std::string_view mixer = "Mixer"; + fillPlantToplogyMixerRow2(state, loopType, thisLoop.Name, loopSide, thisLoopSide.Mixer.Name, rowCounter); + rowCounter += 1; + } } // Outlet Branch auto &thisBranch = thisLoopSide.Branch(thisLoopSide.TotalBranches); - // fillPlantToplogyRow(state, thisBranch.Name, branch, loopSide, loopType, thisLoop.Name, thisLoop.FluidName, repOffset); - // fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, "", "", rowCounter); for (int compNum = 1; compNum <= thisBranch.TotalComponents; ++compNum) { auto &thisComp = thisBranch.Comp(compNum); - // fillPlantToplogyRow(state, thisComp.Name, thisComp.TypeOf, loopSide, branch, thisBranch.Name, thisLoop.FluidName, repOffset); fillPlantToplogyComponentRow2(state, loopType, thisLoop.Name, loopSide, thisBranch.Name, thisComp.TypeOf, thisComp.Name, rowCounter); } } } } -// void fillPlantToplogyRow(EnergyPlusData &state, -// const std::string_view &compName, -// const std::string_view &compType, -// const std::string_view &side, -// const std::string_view &parentType, -// const std::string_view &parentName, -// const std::string_view &fluidName, -// const int reportOffset) -//{ -// auto &orp = state.dataOutRptPredefined; -// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantCompType + reportOffset, compName, compType); -// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide + reportOffset, compName, side); -// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantParType + reportOffset, compName, parentType); -// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantParName + reportOffset, compName, parentName); -// OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantConType + reportOffset, compName, fluidName); -// } - -void fillPlantToplogySplitterMixerRow2(EnergyPlusData &state, - const std::string_view &loopType, - const std::string_view &loopName, - const std::string_view &side, - const std::string_view &splitterMixerName, - int &rowCounter) +void fillPlantToplogySplitterRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &splitterName, + int &rowCounter) { auto &orp = state.dataOutRptPredefined; - // s->pdchTopPlantSplitMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter/Mixer Name"); + // s->pdchTopPlantSplitName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Splitter Name"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), loopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), side); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSplitMixName2, format("{}", rowCounter), splitterMixerName); - ++rowCounter; + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSplitName2, format("{}", rowCounter), splitterName); +} +void fillPlantToplogyMixerRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &mixerName, + int &rowCounter) +{ + auto &orp = state.dataOutRptPredefined; + // s->pdchTopPlantMixName2 = newPreDefColumn(state, s->pdstTopPlantLoop2, "Mixer Name"); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopType2, format("{}", rowCounter), loopType); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantLoopName2, format("{}", rowCounter), loopName); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantSide2, format("{}", rowCounter), side); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopPlantMixName2, format("{}", rowCounter), mixerName); } void fillPlantToplogyComponentRow2(EnergyPlusData &state, const std::string_view &loopType, diff --git a/src/EnergyPlus/Plant/PlantManager.hh b/src/EnergyPlus/Plant/PlantManager.hh index bfa81f5c9e6..2274d8a263c 100644 --- a/src/EnergyPlus/Plant/PlantManager.hh +++ b/src/EnergyPlus/Plant/PlantManager.hh @@ -90,13 +90,20 @@ namespace PlantManager { // const std::string_view &fluidName, // const int reportOffset); - void fillPlantToplogySplitterMixerRow2(EnergyPlusData &state, + void fillPlantToplogySplitterRow2(EnergyPlusData &state, const std::string_view &loopType, const std::string_view &loopName, const std::string_view &side, - const std::string_view &splitterMixerName, + const std::string_view &splitterName, int &rowCounter); + void fillPlantToplogyMixerRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &mixerName, + int &rowCounter); + void fillPlantToplogyComponentRow2(EnergyPlusData &state, const std::string_view &loopType, const std::string_view &loopName, From fac4cb19f2402c268bc4c625fcfd708ac04350a6 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 28 Mar 2024 10:38:11 -0500 Subject: [PATCH 037/115] Add FillPredefinedTableOnThermostatSchedules_Test unit test --- .../unit/ZoneTempPredictorCorrector.unit.cc | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc index 7ae16c2693d..8cfcabfa522 100644 --- a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc +++ b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc @@ -70,6 +70,7 @@ #include #include #include +#include #include #include #include @@ -1696,3 +1697,97 @@ TEST_F(EnergyPlusFixture, DownInterpolate4HistoryValues_Test) EXPECT_NEAR(oldValue[2], DSHistoryValue3, 0.000001); EXPECT_NEAR(oldValue[3], DSHistoryValue4, 0.000001); } + + +TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) +{ + using namespace EnergyPlus::OutputReportPredefined; + + + state->dataScheduleMgr->Schedule.allocate(5); + state->dataScheduleMgr->ScheduleInputProcessed = true; + + auto &orp = *state->dataOutRptPredefined; + auto &dzc = *state->dataZoneCtrls; + + SetPredefinedTables(*state); + + dzc.NumTempControlledZones = 4; + dzc.TempControlledZone.allocate(dzc.NumTempControlledZones); + + dzc.TempControlledZone(1).ZoneName = "zoneA"; + dzc.TempControlledZone(1).Name = "stat A"; + dzc.TempControlledZone(1).ControlTypeSchedName = "control schedule A"; + dzc.TempControlledZone(1).NumControlTypes = 1; + dzc.TempControlledZone(1).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(1).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(1).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleHeating; + dzc.TempControlledZone(1).ControlTypeName(1) = "control A"; + dzc.TempControlledZone(1).SchIndx_SingleHeatSetPoint = 1; + state->dataScheduleMgr->Schedule(1).Name = "schA"; + + dzc.TempControlledZone(2).ZoneName = "zoneB"; + dzc.TempControlledZone(2).Name = "stat B"; + dzc.TempControlledZone(2).ControlTypeSchedName = "control schedule B"; + dzc.TempControlledZone(2).NumControlTypes = 1; + dzc.TempControlledZone(2).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(2).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(2).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleCooling; + dzc.TempControlledZone(2).ControlTypeName(1) = "control B"; + dzc.TempControlledZone(2).SchIndx_SingleCoolSetPoint = 2; + state->dataScheduleMgr->Schedule(2).Name = "schB"; + + dzc.TempControlledZone(3).ZoneName = "zoneC"; + dzc.TempControlledZone(3).Name = "stat C"; + dzc.TempControlledZone(3).ControlTypeSchedName = "control schedule C"; + dzc.TempControlledZone(3).NumControlTypes = 1; + dzc.TempControlledZone(3).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(3).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(3).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleHeatCool; + dzc.TempControlledZone(3).ControlTypeName(1) = "control C"; + dzc.TempControlledZone(3).SchIndx_SingleHeatCoolSetPoint = 3; + state->dataScheduleMgr->Schedule(3).Name = "schC"; + + dzc.TempControlledZone(4).ZoneName = "zoneD"; + dzc.TempControlledZone(4).Name = "stat D"; + dzc.TempControlledZone(4).ControlTypeSchedName = "control schedule D"; + dzc.TempControlledZone(4).NumControlTypes = 1; + dzc.TempControlledZone(4).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(4).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); + dzc.TempControlledZone(4).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand; + dzc.TempControlledZone(4).ControlTypeName(1) = "control D"; + dzc.TempControlledZone(4).SchIndx_DualSetPointWDeadBandHeat = 4; + dzc.TempControlledZone(4).SchIndx_DualSetPointWDeadBandCool = 5; + state->dataScheduleMgr->Schedule(4).Name = "schD"; + state->dataScheduleMgr->Schedule(5).Name = "schE"; + + FillPredefinedTableOnThermostatSchedules(*state); + + EXPECT_EQ("stat A", RetrievePreDefTableEntry(*state, orp.pdchStatName, "zoneA")); + EXPECT_EQ("control schedule A", RetrievePreDefTableEntry(*state, orp.pdchStatCtrlTypeSchd, "zoneA")); + EXPECT_EQ("SingleHeating", RetrievePreDefTableEntry(*state, orp.pdchStatSchdType1, "zoneA")); + EXPECT_EQ("control A", RetrievePreDefTableEntry(*state, orp.pdchStatSchdTypeName1, "zoneA")); + EXPECT_EQ("schA", RetrievePreDefTableEntry(*state, orp.pdchStatSchdCoolName, "zoneA")); + EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchStatSchdHeatName, "zoneA")); + + EXPECT_EQ("stat B", RetrievePreDefTableEntry(*state, orp.pdchStatName, "zoneB")); + EXPECT_EQ("control schedule B", RetrievePreDefTableEntry(*state, orp.pdchStatCtrlTypeSchd, "zoneB")); + EXPECT_EQ("SingleCooling", RetrievePreDefTableEntry(*state, orp.pdchStatSchdType1, "zoneB")); + EXPECT_EQ("control B", RetrievePreDefTableEntry(*state, orp.pdchStatSchdTypeName1, "zoneB")); + EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchStatSchdCoolName, "zoneB")); + EXPECT_EQ("schB", RetrievePreDefTableEntry(*state, orp.pdchStatSchdHeatName, "zoneB")); + + EXPECT_EQ("stat C", RetrievePreDefTableEntry(*state, orp.pdchStatName, "zoneC")); + EXPECT_EQ("control schedule C", RetrievePreDefTableEntry(*state, orp.pdchStatCtrlTypeSchd, "zoneC")); + EXPECT_EQ("SingleHeatCool", RetrievePreDefTableEntry(*state, orp.pdchStatSchdType1, "zoneC")); + EXPECT_EQ("control C", RetrievePreDefTableEntry(*state, orp.pdchStatSchdTypeName1, "zoneC")); + EXPECT_EQ("schC", RetrievePreDefTableEntry(*state, orp.pdchStatSchdCoolName, "zoneC")); + EXPECT_EQ("schC", RetrievePreDefTableEntry(*state, orp.pdchStatSchdHeatName, "zoneC")); + + EXPECT_EQ("stat D", RetrievePreDefTableEntry(*state, orp.pdchStatName, "zoneD")); + EXPECT_EQ("control schedule D", RetrievePreDefTableEntry(*state, orp.pdchStatCtrlTypeSchd, "zoneD")); + EXPECT_EQ("DualSetPointWithDeadBand", RetrievePreDefTableEntry(*state, orp.pdchStatSchdType1, "zoneD")); + EXPECT_EQ("control D", RetrievePreDefTableEntry(*state, orp.pdchStatSchdTypeName1, "zoneD")); + EXPECT_EQ("schE", RetrievePreDefTableEntry(*state, orp.pdchStatSchdCoolName, "zoneD")); + EXPECT_EQ("schD", RetrievePreDefTableEntry(*state, orp.pdchStatSchdHeatName, "zoneD")); +} From 32e171307ad611f18f14978bcab39f2f6ba515fc Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 29 Mar 2024 06:15:22 -0500 Subject: [PATCH 038/115] Add new Construction.unit.cc and Construction_reportLayers unit test. --- tst/EnergyPlus/unit/CMakeLists.txt | 1 + tst/EnergyPlus/unit/Construction.unit.cc | 127 ++++++++++++++++++ .../unit/ZoneTempPredictorCorrector.unit.cc | 1 - 3 files changed, 128 insertions(+), 1 deletion(-) create mode 100644 tst/EnergyPlus/unit/Construction.unit.cc diff --git a/tst/EnergyPlus/unit/CMakeLists.txt b/tst/EnergyPlus/unit/CMakeLists.txt index 409fd871cd0..0bf70de41ce 100644 --- a/tst/EnergyPlus/unit/CMakeLists.txt +++ b/tst/EnergyPlus/unit/CMakeLists.txt @@ -70,6 +70,7 @@ set(test_src Coils/CoilCoolingDXCurveFitSpeed.unit.cc Coils/CoilCoolingDXFixture.hh CondenserLoopTowers.unit.cc + Construction.unit.cc ConstructionInternalSource.unit.cc ConvectionCoefficients.unit.cc CoolTower.unit.cc diff --git a/tst/EnergyPlus/unit/Construction.unit.cc b/tst/EnergyPlus/unit/Construction.unit.cc new file mode 100644 index 00000000000..b2fa78756b9 --- /dev/null +++ b/tst/EnergyPlus/unit/Construction.unit.cc @@ -0,0 +1,127 @@ +// EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois, +// The Regents of the University of California, through Lawrence Berkeley National Laboratory +// (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge +// National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other +// contributors. All rights reserved. +// +// NOTICE: This Software was developed under funding from the U.S. Department of Energy and the +// U.S. Government consequently retains certain rights. As such, the U.S. Government has been +// granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, +// worldwide license in the Software to reproduce, distribute copies to the public, prepare +// derivative works, and perform publicly and display publicly, and to permit others to do so. +// +// Redistribution and use in source and binary forms, with or without modification, are permitted +// provided that the following conditions are met: +// +// (1) Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// (2) Redistributions in binary form must reproduce the above copyright notice, this list of +// conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, +// the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be +// used to endorse or promote products derived from this software without specific prior +// written permission. +// +// (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form +// without changes from the version obtained under this License, or (ii) Licensee makes a +// reference solely to the software portion of its product, Licensee must refer to the +// software as "EnergyPlus version X" software, where "X" is the version number Licensee +// obtained under this License and may not use a different name for the software. Except as +// specifically required in this Section (4), Licensee shall not use in a company name, a +// product name, in advertising, publicity, or other promotional activities any name, trade +// name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly +// similar designation, without the U.S. Department of Energy's prior written consent. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY +// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// EnergyPlus::Construction Unit Tests + +// Google Test Headers +#include + +// EnergyPlus Headers +#include +#include +#include + +#include "Fixtures/EnergyPlusFixture.hh" + +using namespace EnergyPlus; +using namespace EnergyPlus::Construction; + + +TEST_F(EnergyPlusFixture, Construction_reportLayers) +{ + using namespace EnergyPlus::OutputReportPredefined; + + auto &c = state->dataConstruction; + auto &m = state->dataMaterial; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + m->TotMaterials = 8; + for (int i = 1; i <= m->TotMaterials; i++) { + Material::MaterialChild *p = new Material::MaterialChild; + m->Material.push_back(p); + } + + m->Material(1)->Name = "mat a"; + m->Material(2)->Name = "mat b"; + m->Material(3)->Name = "mat c"; + m->Material(4)->Name = "mat d"; + m->Material(5)->Name = "mat e"; + m->Material(6)->Name = "mat f"; + m->Material(7)->Name = "mat g"; + m->Material(8)->Name = "mat h"; + + c->Construct.allocate(3); + + c->Construct(1).Name = "ConsB"; + c->Construct(1).TotLayers = 1; + c->Construct(1).LayerPoint(1) = 2; + c->Construct(1).reportLayers(*state); + + c->Construct(2).Name = "ConsCEGAH"; + c->Construct(2).TotLayers = 5; + c->Construct(2).LayerPoint(1) = 3; + c->Construct(2).LayerPoint(2) = 5; + c->Construct(2).LayerPoint(3) = 7; + c->Construct(2).LayerPoint(4) = 1; + c->Construct(2).LayerPoint(5) = 8; + c->Construct(2).reportLayers(*state); + + c->Construct(3).Name = "ConsDA"; + c->Construct(3).TotLayers = 2; + c->Construct(3).LayerPoint(1) = 4; + c->Construct(3).LayerPoint(2) = 1; + c->Construct(3).reportLayers(*state); + + + EXPECT_EQ("mat b", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[0], "ConsB")); + EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[1], "ConsB")); + + EXPECT_EQ("mat c", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[0], "ConsCEGAH")); + EXPECT_EQ("mat e", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[1], "ConsCEGAH")); + EXPECT_EQ("mat g", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[2], "ConsCEGAH")); + EXPECT_EQ("mat a", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[3], "ConsCEGAH")); + EXPECT_EQ("mat h", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[4], "ConsCEGAH")); + EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[5], "ConsCEGAH")); + + EXPECT_EQ("mat d", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[0], "ConsDA")); + EXPECT_EQ("mat a", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[1], "ConsDA")); + EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[2], "ConsDA")); +} + + diff --git a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc index 8cfcabfa522..7fdcbe36508 100644 --- a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc +++ b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc @@ -1703,7 +1703,6 @@ TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) { using namespace EnergyPlus::OutputReportPredefined; - state->dataScheduleMgr->Schedule.allocate(5); state->dataScheduleMgr->ScheduleInputProcessed = true; From c8d55d1f3111d7759e547db78429fdcd80d6be6d Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 29 Mar 2024 13:57:30 -0500 Subject: [PATCH 039/115] Add SingleDuctAirTerminal_reportTerminalUnit unit test. --- tst/EnergyPlus/unit/SingleDuct.unit.cc | 104 +++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/tst/EnergyPlus/unit/SingleDuct.unit.cc b/tst/EnergyPlus/unit/SingleDuct.unit.cc index b570148cd77..efef8515537 100644 --- a/tst/EnergyPlus/unit/SingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/SingleDuct.unit.cc @@ -58,6 +58,7 @@ #include #include #include +#include #include #include #include @@ -67,6 +68,7 @@ #include #include #include +#include #include #include #include @@ -3014,3 +3016,105 @@ TEST_F(EnergyPlusFixture, VAVConstantVolTU_Reheat_Sizing) EXPECT_NEAR(actualCoilSize, 12192.0, 0.1); EXPECT_NEAR(actualCoilSize, 2.0 * desCoilSize, 0.1); // heating coil is twice the size of autosized value } + +TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) +{ + using namespace EnergyPlus::OutputReportPredefined; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + state->dataScheduleMgr->ScheduleInputProcessed = true; + auto &sch = state->dataScheduleMgr->Schedule; + sch.allocate(5); + sch(1).Name = "schA"; + sch(2).Name = "schB"; + + auto &adu = state->dataDefineEquipment->AirDistUnit; + adu.allocate(2); + adu(1).Name = "ADU a"; + adu(1).TermUnitSizingNum = 1; + + auto &siz = state->dataSize->TermUnitFinalZoneSizing; + siz.allocate(2); + siz(1).DesCoolVolFlowMin = 0.15; + siz(1).MinOA = 0.05; + siz(1).CoolDesTemp = 12.5; + siz(1).HeatDesTemp = 40.0; + siz(1).DesHeatLoad = 2000.0; + siz(1).DesCoolLoad = 3000.0; + + auto &sdat = state->dataSingleDuct->sd_airterminal; + sdat.allocate(2); + sdat(1).ADUNum = 1; + sdat(1).sysType = "AirTerminal:SingleDuct:ConstantVolume:NoReheat"; + sdat(1).MaxAirVolFlowRate = 0.30; + sdat(1).ZoneMinAirFracSchPtr = 1; + sdat(1).MaxAirVolFlowRateDuringReheat = 0.25; + sdat(1).OARequirementsPtr = 0; + sdat(1).ReheatComp = "watercoil"; + sdat(1).FanType = "variable"; + sdat(1).FanName = "FanA"; + + sdat(1).reportTerminalUnit(*state); + + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU a")); + EXPECT_EQ("0.05", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU a")); + EXPECT_EQ("12.50", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU a")); + EXPECT_EQ("40.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU a")); + EXPECT_EQ("2000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU a")); + EXPECT_EQ("3000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU a")); + EXPECT_EQ("AirTerminal:SingleDuct:ConstantVolume:NoReheat", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU a")); + EXPECT_EQ("0.30", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU a")); + EXPECT_EQ("schA", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a")); + EXPECT_EQ("0.25", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); + EXPECT_EQ("watercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); + EXPECT_EQ("variable", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("FanA", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); + + adu(2).Name = "ADU b"; + adu(2).TermUnitSizingNum = 2; + + siz(2).DesCoolVolFlowMin = 0.16; + siz(2).MinOA = 0.06; + siz(2).CoolDesTemp = 12.6; + siz(2).HeatDesTemp = 41.0; + siz(2).DesHeatLoad = 2100.0; + siz(2).DesCoolLoad = 3100.0; + + sdat(2).ADUNum = 2; + sdat(2).sysType = "AirTerminal:SingleDuct:ConstantVolume:Reheat"; + sdat(2).MaxAirVolFlowRate = 0.31; + sdat(2).ZoneMinAirFracSchPtr = 0; + sdat(2).MaxAirVolFlowRateDuringReheat = 0.26; + sdat(2).OARequirementsPtr = 1; + sdat(2).ReheatComp = "furncoil"; + sdat(2).FanType = "single"; + sdat(2).FanName = "FanB"; + + auto &oa = state->dataSize->OARequirements; + oa.allocate(1); + oa(1).OAFlowFracSchPtr = 2; + + sdat(2).reportTerminalUnit(*state); + + EXPECT_EQ("0.16", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU b")); + EXPECT_EQ("0.06", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU b")); + EXPECT_EQ("12.60", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU b")); + EXPECT_EQ("41.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU b")); + EXPECT_EQ("2100.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU b")); + EXPECT_EQ("3100.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU b")); + EXPECT_EQ("AirTerminal:SingleDuct:ConstantVolume:Reheat", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU b")); + EXPECT_EQ("0.31", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU b")); + EXPECT_EQ("0.26", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU b")); + EXPECT_EQ("schB", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU b")); + EXPECT_EQ("furncoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU b")); + EXPECT_EQ("single", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU b")); + EXPECT_EQ("FanB", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU b")); +} From c543627fde306395ae63ce9fdbf5fd49544137ab Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 1 Apr 2024 10:01:01 -0500 Subject: [PATCH 040/115] Add DualDuctAirTerminal_reportTerminalUnit unit test --- tst/EnergyPlus/unit/DualDuct.unit.cc | 96 ++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) diff --git a/tst/EnergyPlus/unit/DualDuct.unit.cc b/tst/EnergyPlus/unit/DualDuct.unit.cc index 7394f05c02b..e888093f63c 100644 --- a/tst/EnergyPlus/unit/DualDuct.unit.cc +++ b/tst/EnergyPlus/unit/DualDuct.unit.cc @@ -56,6 +56,7 @@ #include "Fixtures/EnergyPlusFixture.hh" #include #include +#include #include #include #include @@ -67,6 +68,7 @@ #include #include #include +#include #include #include #include @@ -524,3 +526,97 @@ TEST_F(EnergyPlusFixture, DualDuctVAVAirTerminals_MinFlowTurnDownTest) thisDDAirTerminal.ZoneTurndownMinAirFrac); EXPECT_EQ(0.0, state->dataLoopNodes->Node(ColdInNode).MassFlowRate); } + +TEST_F(EnergyPlusFixture, DualDuctAirTerminal_reportTerminalUnit) +{ + using namespace EnergyPlus::OutputReportPredefined; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + state->dataScheduleMgr->ScheduleInputProcessed = true; + auto &sch = state->dataScheduleMgr->Schedule; + sch.allocate(5); + sch(1).Name = "schA"; + sch(2).Name = "schB"; + + auto &adu = state->dataDefineEquipment->AirDistUnit; + adu.allocate(2); + adu(1).Name = "ADU a"; + adu(1).TermUnitSizingNum = 1; + + auto &siz = state->dataSize->TermUnitFinalZoneSizing; + siz.allocate(2); + siz(1).DesCoolVolFlowMin = 0.15; + siz(1).MinOA = 0.05; + siz(1).CoolDesTemp = 12.5; + siz(1).HeatDesTemp = 40.0; + siz(1).DesHeatLoad = 2000.0; + siz(1).DesCoolLoad = 3000.0; + + auto &ddat = state->dataDualDuct->dd_airterminal; + ddat.allocate(2); + ddat(1).ADUNum = 1; + ddat(1).DamperType = DualDuctDamper::ConstantVolume; + ddat(1).MaxAirVolFlowRate = 0.30; + ddat(1).ZoneTurndownMinAirFracSchPtr = 1; + ddat(1).OARequirementsPtr = 0; + + ddat(1).reportTerminalUnit(*state); + + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU a")); + EXPECT_EQ("0.05", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU a")); + EXPECT_EQ("12.50", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU a")); + EXPECT_EQ("40.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU a")); + EXPECT_EQ("2000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU a")); + EXPECT_EQ("3000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU a")); + EXPECT_EQ("ConstantVolume", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU a")); + EXPECT_EQ("0.30", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU a")); + EXPECT_EQ("schA", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); + + adu(2).Name = "ADU b"; + adu(2).TermUnitSizingNum = 2; + + siz(2).DesCoolVolFlowMin = 0.16; + siz(2).MinOA = 0.06; + siz(2).CoolDesTemp = 12.6; + siz(2).HeatDesTemp = 41.0; + siz(2).DesHeatLoad = 2100.0; + siz(2).DesCoolLoad = 3100.0; + + ddat(2).ADUNum = 2; + ddat(2).DamperType = DualDuctDamper::VariableVolume; + ddat(2).MaxAirVolFlowRate = 0.31; + ddat(2).ZoneTurndownMinAirFracSchPtr = 0; + ddat(2).OARequirementsPtr = 1; + + auto &oa = state->dataSize->OARequirements; + oa.allocate(1); + oa(1).OAFlowFracSchPtr = 2; + + ddat(2).reportTerminalUnit(*state); + + EXPECT_EQ("0.16", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU b")); + EXPECT_EQ("0.06", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU b")); + EXPECT_EQ("12.60", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU b")); + EXPECT_EQ("41.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU b")); + EXPECT_EQ("2100.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU b")); + EXPECT_EQ("3100.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU b")); + EXPECT_EQ("VariableVolume", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU b")); + EXPECT_EQ("0.31", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU b")); + EXPECT_EQ("schB", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU b")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU b")); +} From 931c86b3aa26d4a4427a8e136b206d41be04ffb3 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 1 Apr 2024 11:59:04 -0500 Subject: [PATCH 041/115] Add unit test HVACCooledBeam_reportTerminalUnit in new file HVACCooledBeam.unit.cc --- tst/EnergyPlus/unit/CMakeLists.txt | 1 + tst/EnergyPlus/unit/HVACCooledBeam.unit.cc | 122 +++++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 tst/EnergyPlus/unit/HVACCooledBeam.unit.cc diff --git a/tst/EnergyPlus/unit/CMakeLists.txt b/tst/EnergyPlus/unit/CMakeLists.txt index 0bf70de41ce..b8df026515d 100644 --- a/tst/EnergyPlus/unit/CMakeLists.txt +++ b/tst/EnergyPlus/unit/CMakeLists.txt @@ -121,6 +121,7 @@ set(test_src GeneralRoutines.unit.cc GroundHeatExchangers.unit.cc HVACControllers.unit.cc + HVACCooledBeam.unit.cc HVACDXSystem.unit.cc HVACDXHeatPumpSystem.unit.cc HVACFan.unit.cc diff --git a/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc b/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc new file mode 100644 index 00000000000..039197aad69 --- /dev/null +++ b/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc @@ -0,0 +1,122 @@ +// EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois, +// The Regents of the University of California, through Lawrence Berkeley National Laboratory +// (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge +// National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other +// contributors. All rights reserved. +// +// NOTICE: This Software was developed under funding from the U.S. Department of Energy and the +// U.S. Government consequently retains certain rights. As such, the U.S. Government has been +// granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, +// worldwide license in the Software to reproduce, distribute copies to the public, prepare +// derivative works, and perform publicly and display publicly, and to permit others to do so. +// +// Redistribution and use in source and binary forms, with or without modification, are permitted +// provided that the following conditions are met: +// +// (1) Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// (2) Redistributions in binary form must reproduce the above copyright notice, this list of +// conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, +// the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be +// used to endorse or promote products derived from this software without specific prior +// written permission. +// +// (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form +// without changes from the version obtained under this License, or (ii) Licensee makes a +// reference solely to the software portion of its product, Licensee must refer to the +// software as "EnergyPlus version X" software, where "X" is the version number Licensee +// obtained under this License and may not use a different name for the software. Except as +// specifically required in this Section (4), Licensee shall not use in a company name, a +// product name, in advertising, publicity, or other promotional activities any name, trade +// name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly +// similar designation, without the U.S. Department of Energy's prior written consent. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY +// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// EnergyPlus::Construction Unit Tests + +// Google Test Headers +#include + +// EnergyPlus Headers +#include +#include +#include +#include +#include +#include +#include + + +#include "Fixtures/EnergyPlusFixture.hh" + +using namespace EnergyPlus; +using namespace EnergyPlus::HVACCooledBeam; +using namespace EnergyPlus::DataPlant; + + +TEST_F(EnergyPlusFixture, HVACCooledBeam_reportTerminalUnit) +{ + using namespace EnergyPlus::OutputReportPredefined; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + state->dataScheduleMgr->ScheduleInputProcessed = true; + auto &sch = state->dataScheduleMgr->Schedule; + sch.allocate(5); + sch(1).Name = "schA"; + sch(2).Name = "schB"; + + auto &adu = state->dataDefineEquipment->AirDistUnit; + adu.allocate(2); + adu(1).Name = "ADU a"; + adu(1).TermUnitSizingNum = 1; + + auto &siz = state->dataSize->TermUnitFinalZoneSizing; + siz.allocate(2); + siz(1).DesCoolVolFlowMin = 0.15; + siz(1).MinOA = 0.05; + siz(1).CoolDesTemp = 12.5; + siz(1).HeatDesTemp = 40.0; + siz(1).DesHeatLoad = 2000.0; + siz(1).DesCoolLoad = 3000.0; + + auto &cb = state->dataHVACCooledBeam->CoolBeam; + cb.allocate(2); + cb(1).ADUNum = 1; + cb(1).UnitType = "AirTerminal:SingleDuct:ConstantVolume:CooledBeam"; + cb(1).MaxAirVolFlow = 0.30; + cb(1).CBTypeString = "active"; + + cb(1).reportTerminalUnit(*state); + + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU a")); + EXPECT_EQ("0.05", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU a")); + EXPECT_EQ("12.50", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU a")); + EXPECT_EQ("40.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU a")); + EXPECT_EQ("2000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU a")); + EXPECT_EQ("3000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU a")); + EXPECT_EQ("AirTerminal:SingleDuct:ConstantVolume:CooledBeam", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU a")); + EXPECT_EQ("0.30", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); + EXPECT_EQ("active", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); +} From 744bb4f639c8371ff672833a27e889bdc49b102d Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Mon, 1 Apr 2024 17:34:50 -0500 Subject: [PATCH 042/115] Revise air loop supply side topology --- src/EnergyPlus/OutputReportPredefined.cc | 10 +++--- src/EnergyPlus/OutputReportPredefined.hh | 10 +++--- src/EnergyPlus/SystemReports.cc | 46 ++++++++++-------------- 3 files changed, 27 insertions(+), 39 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 2c9cb9dbf92..979b224a92e 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -914,15 +914,13 @@ namespace OutputReportPredefined { s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); - s->pdchTopAirUpSplitMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Upstream Splitter or Mixer Name"); + s->pdchTopAirSplitName = newPreDefColumn(state, s->pdstTopAirLoop, "Splitter Name"); s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); - s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); - s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); - s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); - s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); - s->pdchTopAirDownSplitMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Downstream Splitter or Mixer Name"); + s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); + s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); + s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 7d38e97fa56..d394452e35e 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -887,15 +887,13 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdstTopAirLoop = 0; int pdchTopAirLoopName = 0; - int pdchTopAirUpSplitMixName = 0; + int pdchTopAirSplitName = 0; int pdchTopAirBranchName = 0; int pdchTopAirCompType = 0; int pdchTopAirCompName = 0; - int pdchTopAirSubCompType = 0; - int pdchTopAirSubCompName = 0; - int pdchTopAirSubSubCompType = 0; - int pdchTopAirSubSubCompName = 0; - int pdchTopAirDownSplitMixName = 0; + int pdchTopAirMixName = 0; + int pdchTopAirParentCompType = 0; + int pdchTopAirParentCompName = 0; int pdstTopAirDemand = 0; int pdchTopAirDemandName = 0; diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index e6a57528325..0f522c900b7 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4768,13 +4768,13 @@ void reportAirLoopToplogy(EnergyPlusData &state) { // s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); // s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); + // s->pdchTopAirSplitName = newPreDefColumn(state, s->pdstTopAirLoop, "Splitter Name"); // s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); // s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); - // s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); - // s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); - // s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); - // s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); + // s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); + // s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); + // s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); auto &orp = state.dataOutRptPredefined; int rowCounter = 1; @@ -4787,51 +4787,43 @@ void reportAirLoopToplogy(EnergyPlusData &state) if (pas.Splitter.Exists) { for (int outNum : pas.Splitter.BranchNumOut) { if (outNum == BranchNum) { - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirUpSplitMixName, format("{}", rowCounter), pas.Splitter.Name); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSplitName, format("{}", rowCounter), pas.Splitter.Name); break; } } } - if (pas.Mixer.Exists) { - if (pas.Mixer.BranchNumOut == BranchNum) { - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirUpSplitMixName, format("{}", rowCounter), pas.Mixer.Name); - } - } for (int CompNum = 1; CompNum <= pasBranch.TotalComponents; ++CompNum) { auto &pasBranchComp = pasBranch.Comp(CompNum); - fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + if (pasBranchComp.NumSubComps == 0) { + fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + } for (int SubCompNum = 1; SubCompNum <= pasBranchComp.NumSubComps; ++SubCompNum) { auto &pasBranchSubComp = pasBranchComp.SubComp(SubCompNum); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); - fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + if (pasBranchSubComp.NumSubSubComps == 0) { + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchComp.Name); + fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchSubComp.TypeOf, pasBranchSubComp.Name, rowCounter); + } for (int SubSubCompNum = 1; SubSubCompNum <= pasBranchSubComp.NumSubSubComps; ++SubSubCompNum) { auto &pasBranchSubSubComp = pasBranchSubComp.SubSubComp(SubSubCompNum); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSubSubCompType, format("{}", rowCounter), pasBranchSubSubComp.TypeOf); + state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSubSubCompName, format("{}", rowCounter), pasBranchSubSubComp.Name); - fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchSubComp.Name); + fillAirloopToplogyComponentRow( + state, pas.Name, pasBranch.Name, pasBranchSubSubComp.TypeOf, pasBranchSubSubComp.Name, rowCounter); } } } if (pas.Mixer.Exists) { for (int inNum : pas.Mixer.BranchNumIn) { if (inNum == BranchNum) { - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirDownSplitMixName, format("{}", rowCounter - 1), pas.Mixer.Name); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirMixName, format("{}", rowCounter - 1), pas.Mixer.Name); break; } } } - if (pas.Splitter.Exists) { - if (pas.Splitter.BranchNumIn == BranchNum) { - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDownSplitMixName, format("{}", rowCounter - 1), pas.Splitter.Name); - } - } } } From 7f2d0ce04994960e4b471ad8600e0254afee45b0 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Mon, 1 Apr 2024 17:56:19 -0500 Subject: [PATCH 043/115] Fix fan type name in PIU reportTerminalUnit --- src/EnergyPlus/PoweredInductionUnits.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 1e16f1e9fe4..b3497197c87 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -2187,7 +2187,7 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HCoilNamesUC[(int)this->HCoilType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNamesUC[(int)this->Fan_Num]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::cFanTypes((int)this->Fan_Num)); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } From 9a142bfca1e8e1b8a584e5bdc01965125dbf0710 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 2 Apr 2024 13:28:04 -0500 Subject: [PATCH 044/115] Revise air loop supply side topology - more --- src/EnergyPlus/OutputReportPredefined.cc | 5 ++++- src/EnergyPlus/OutputReportPredefined.hh | 3 +++ src/EnergyPlus/SystemReports.cc | 23 +++++++++++++++++------ src/EnergyPlus/SystemReports.hh | 2 ++ 4 files changed, 26 insertions(+), 7 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 979b224a92e..441e165bb10 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -915,12 +915,15 @@ namespace OutputReportPredefined { s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); s->pdchTopAirSplitName = newPreDefColumn(state, s->pdstTopAirLoop, "Splitter Name"); - s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); + s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Name"); + s->pdchTopAirSupplyBranchType = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Type"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); + s->pdchTopAirParentCompType2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type 2"); + s->pdchTopAirParentCompName2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name 2"); s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index d394452e35e..4993680d366 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -889,11 +889,14 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopAirLoopName = 0; int pdchTopAirSplitName = 0; int pdchTopAirBranchName = 0; + int pdchTopAirSupplyBranchType = 0; int pdchTopAirCompType = 0; int pdchTopAirCompName = 0; int pdchTopAirMixName = 0; int pdchTopAirParentCompType = 0; int pdchTopAirParentCompName = 0; + int pdchTopAirParentCompType2 = 0; + int pdchTopAirParentCompName2 = 0; int pdstTopAirDemand = 0; int pdchTopAirDemandName = 0; diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 0f522c900b7..39d4dbd91dc 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4769,12 +4769,15 @@ void reportAirLoopToplogy(EnergyPlusData &state) // s->pdstTopAirLoop = newPreDefSubTable(state, s->pdrTopology, "Air Loop Supply Side Component Arrangement"); // s->pdchTopAirLoopName = newPreDefColumn(state, s->pdstTopAirLoop, "Airloop Name"); // s->pdchTopAirSplitName = newPreDefColumn(state, s->pdstTopAirLoop, "Splitter Name"); - // s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Branch Name"); + // s->pdchTopAirBranchName = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Name"); + // s->pdchTopAirSupplyBranchType = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Type"); // s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); // s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); // s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); // s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); + // s->pdchTopAirParentCompType2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type 2"); + // s->pdchTopAirParentCompName2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name 2"); auto &orp = state.dataOutRptPredefined; int rowCounter = 1; @@ -4795,7 +4798,8 @@ void reportAirLoopToplogy(EnergyPlusData &state) for (int CompNum = 1; CompNum <= pasBranch.TotalComponents; ++CompNum) { auto &pasBranchComp = pasBranch.Comp(CompNum); if (pasBranchComp.NumSubComps == 0) { - fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); + fillAirloopToplogyComponentRow( + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); } for (int SubCompNum = 1; SubCompNum <= pasBranchComp.NumSubComps; ++SubCompNum) { auto &pasBranchSubComp = pasBranchComp.SubComp(SubCompNum); @@ -4803,16 +4807,20 @@ void reportAirLoopToplogy(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchComp.TypeOf); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchComp.Name); - fillAirloopToplogyComponentRow(state, pas.Name, pasBranch.Name, pasBranchSubComp.TypeOf, pasBranchSubComp.Name, rowCounter); + fillAirloopToplogyComponentRow( + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchSubComp.TypeOf, pasBranchSubComp.Name, rowCounter); } for (int SubSubCompNum = 1; SubSubCompNum <= pasBranchSubComp.NumSubSubComps; ++SubSubCompNum) { auto &pasBranchSubSubComp = pasBranchSubComp.SubSubComp(SubSubCompNum); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); + state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchComp.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirParentCompType2, format("{}", rowCounter), pasBranchSubComp.TypeOf); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchSubComp.Name); + state, orp->pdchTopAirParentCompName2, format("{}", rowCounter), pasBranchSubComp.Name); fillAirloopToplogyComponentRow( - state, pas.Name, pasBranch.Name, pasBranchSubSubComp.TypeOf, pasBranchSubSubComp.Name, rowCounter); + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchSubSubComp.TypeOf, pasBranchSubSubComp.Name, rowCounter); } } } @@ -4946,6 +4954,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) void fillAirloopToplogyComponentRow(EnergyPlusData &state, const std::string_view &loopName, const std::string_view &branchName, + const DataHVACGlobals::AirDuctType ductType, const std::string_view &compType, const std::string_view &compName, int &rowCounter) @@ -4957,6 +4966,8 @@ void fillAirloopToplogyComponentRow(EnergyPlusData &state, // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), loopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirBranchName, format("{}", rowCounter), branchName); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyBranchType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)ductType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompType, format("{}", rowCounter), compType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompName, format("{}", rowCounter), compName); ++rowCounter; diff --git a/src/EnergyPlus/SystemReports.hh b/src/EnergyPlus/SystemReports.hh index dc3d2c90bda..2c9aabee046 100644 --- a/src/EnergyPlus/SystemReports.hh +++ b/src/EnergyPlus/SystemReports.hh @@ -54,6 +54,7 @@ // EnergyPlus Headers #include #include +#include #include #include @@ -336,6 +337,7 @@ namespace SystemReports { void fillAirloopToplogyComponentRow(EnergyPlusData &state, const std::string_view &loopName, const std::string_view &branchName, + const DataHVACGlobals::AirDuctType ductType, const std::string_view &compType, const std::string_view &compName, int &rowCounter); From 7d0a21e605fb29f3cb9e862ec474a7d592714f2a Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 2 Apr 2024 16:55:45 -0500 Subject: [PATCH 045/115] Add SingleDuctInduction_reportTerminalUnit unit test --- .../unit/AirTerminalSingleDuct.unit.cc | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc index aaa67756f8b..44b4d8c4fd3 100644 --- a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc @@ -71,6 +71,7 @@ #include #include #include +#include #include #include #include @@ -1832,4 +1833,55 @@ TEST_F(EnergyPlusFixture, VAVHeatCoolReheatAirTerminal_ZoneOAVolumeFlowRateTest) EXPECT_EQ(expect_OutdoorAirFlowRate, thisHeatCoolAT.OutdoorAirFlowRate); } +TEST_F(EnergyPlusFixture, SingleDuctInduction_reportTerminalUnit) +{ + using namespace EnergyPlus::OutputReportPredefined; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + auto &adu = state->dataDefineEquipment->AirDistUnit; + adu.allocate(2); + adu(1).Name = "ADU a"; + adu(1).TermUnitSizingNum = 1; + + auto &siz = state->dataSize->TermUnitFinalZoneSizing; + siz.allocate(2); + siz(1).DesCoolVolFlowMin = 0.15; + siz(1).MinOA = 0.05; + siz(1).CoolDesTemp = 12.5; + siz(1).HeatDesTemp = 40.0; + siz(1).DesHeatLoad = 2000.0; + siz(1).DesCoolLoad = 3000.0; + + auto &sdiu = state->dataHVACSingleDuctInduc->IndUnit; + sdiu.allocate(2); + sdiu(1).ADUNum = 1; + sdiu(1).UnitType = "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction"; + sdiu(1).MaxPriAirMassFlow = 0.30; + sdiu(1).MaxSecAirMassFlow = 0.15; + sdiu(1).HCoilType = "hotwatercoil"; + sdiu(1).CCoilType = "coldwatercoil"; + + sdiu(1).reportTerminalUnit(*state); + + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU a")); + EXPECT_EQ("0.05", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU a")); + EXPECT_EQ("12.50", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU a")); + EXPECT_EQ("40.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU a")); + EXPECT_EQ("2000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU a")); + EXPECT_EQ("3000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU a")); + EXPECT_EQ("AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU a")); + EXPECT_EQ("0.30", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU a")); + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); + EXPECT_EQ("hotwatercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); + EXPECT_EQ("coldwatercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); +} + + } // namespace EnergyPlus From 5d045f4430f8b7b8d752ac832b8ccb86cee4daa6 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 2 Apr 2024 17:02:28 -0500 Subject: [PATCH 046/115] Revise air loop demand side topology --- src/EnergyPlus/DataZoneEquipment.cc | 10 ++- src/EnergyPlus/DataZoneEquipment.hh | 43 ++++++------ src/EnergyPlus/GeneralRoutines.cc | 6 ++ src/EnergyPlus/OutputReportPredefined.cc | 2 +- src/EnergyPlus/OutputReportPredefined.hh | 2 +- src/EnergyPlus/SimAirServingZones.cc | 5 ++ src/EnergyPlus/SystemReports.cc | 83 +++++++++++++++++++----- 7 files changed, 109 insertions(+), 42 deletions(-) diff --git a/src/EnergyPlus/DataZoneEquipment.cc b/src/EnergyPlus/DataZoneEquipment.cc index f9152d21b45..38645f71408 100644 --- a/src/EnergyPlus/DataZoneEquipment.cc +++ b/src/EnergyPlus/DataZoneEquipment.cc @@ -1101,14 +1101,18 @@ void processZoneEquipmentInput(EnergyPlusData &state, thisEquipConfig.ReturnNode.allocate(NumNodes); thisEquipConfig.ReturnNodeAirLoopNum.allocate(NumNodes); + thisEquipConfig.ReturnNodeRetPathNum.allocate(NumNodes); + thisEquipConfig.ReturnNodeRetPathCompNum.allocate(NumNodes); thisEquipConfig.ReturnNodeInletNum.allocate(NumNodes); thisEquipConfig.FixedReturnFlow.allocate(NumNodes); thisEquipConfig.ReturnNodePlenumNum.allocate(NumNodes); thisEquipConfig.ReturnNodeExhaustNodeNum.allocate(NumNodes); thisEquipConfig.SharedExhaustNode.allocate(NumNodes); - thisEquipConfig.ReturnNode = 0; // initialize to zero here - thisEquipConfig.ReturnNodeAirLoopNum = 0; // initialize to zero here - thisEquipConfig.ReturnNodeInletNum = 0; // initialize to zero here + thisEquipConfig.ReturnNode = 0; // initialize to zero here + thisEquipConfig.ReturnNodeAirLoopNum = 0; // initialize to zero here + thisEquipConfig.ReturnNodeInletNum = 0; // initialize to zero here + thisEquipConfig.ReturnNodeRetPathNum = 0; + thisEquipConfig.ReturnNodeRetPathCompNum = 0; thisEquipConfig.FixedReturnFlow = false; // initialize to false here thisEquipConfig.ReturnNodePlenumNum = 0; // initialize to zero here thisEquipConfig.ReturnNodeExhaustNodeNum = 0; // initialize to zero here diff --git a/src/EnergyPlus/DataZoneEquipment.hh b/src/EnergyPlus/DataZoneEquipment.hh index 310f3d145ab..f33b8ace04c 100644 --- a/src/EnergyPlus/DataZoneEquipment.hh +++ b/src/EnergyPlus/DataZoneEquipment.hh @@ -283,9 +283,10 @@ namespace DataZoneEquipment { bool SupplyAirPathExists; int MainBranchIndex; int SupplyBranchIndex; - int AirDistUnitIndex; // equipment number in EquipList - int TermUnitSizingIndex; // Pointer to TermUnitSizing and TermUnitFinalZoneSizing data for this terminal unit - int SupplyAirPathIndex; + int AirDistUnitIndex; // equipment number in EquipList + int TermUnitSizingIndex; // Pointer to TermUnitSizing and TermUnitFinalZoneSizing data for this terminal unit + int SupplyAirPathIndex; // Pointer to SupplyAirPath serving this terminal unit + int SupplyAirPathOutNodeIndex; // Pointer to SupplyAirPath OutletNode serving this terminal unit Array1D Coil; // Default Constructor @@ -304,18 +305,20 @@ namespace DataZoneEquipment { int EquipListIndex; std::string ControlListName; int ZoneNode; - int NumInletNodes; // number of inlet nodes - int NumExhaustNodes; // number of exhaust nodes - int NumReturnNodes; // number of return air nodes - int NumReturnFlowBasisNodes; // number of return air flow basis nodes - int ReturnFlowSchedPtrNum; // return air flow fraction schedule pointer - bool FlowError; // flow error flag - Array1D_int InletNode; // zone supply air inlet nodes - Array1D_int InletNodeAirLoopNum; // air loop number connected to this inlet node (0 if not an airloop node) - Array1D_int InletNodeADUNum; // AirDistUnit connected to this inlet node (0 if not an ADU node, could be zone equip or direct air) - Array1D_int ExhaustNode; // zone air exhaust nodes - Array1D_int ReturnNode; // zone return air nodes (node numbers) - Array1D_int ReturnNodeAirLoopNum; // air loop number connected to this return node + int NumInletNodes; // number of inlet nodes + int NumExhaustNodes; // number of exhaust nodes + int NumReturnNodes; // number of return air nodes + int NumReturnFlowBasisNodes; // number of return air flow basis nodes + int ReturnFlowSchedPtrNum; // return air flow fraction schedule pointer + bool FlowError; // flow error flag + Array1D_int InletNode; // zone supply air inlet nodes + Array1D_int InletNodeAirLoopNum; // air loop number connected to this inlet node (0 if not an airloop node) + Array1D_int InletNodeADUNum; // AirDistUnit connected to this inlet node (0 if not an ADU node, could be zone equip or direct air) + Array1D_int ExhaustNode; // zone air exhaust nodes + Array1D_int ReturnNode; // zone return air nodes (node numbers) + Array1D_int ReturnNodeAirLoopNum; // air loop number connected to this return node + Array1D_int ReturnNodeRetPathNum; // ReturnPath number connected to this return node + Array1D_int ReturnNodeRetPathCompNum; // ReturnPath component number connected to this return node Array1D_int ReturnNodeInletNum; // zone supply air inlet index that matched this return node (same zone, same airloop) - not the inlet node number Array1D_bool FixedReturnFlow; // true if return node is fixed and cannot be adjusted in CalcZoneReturnFlows @@ -525,17 +528,13 @@ namespace DataZoneEquipment { { // Members std::string Name; - int NumOfComponents; - int OutletNodeNum; + int NumOfComponents = 0; + int OutletNodeNum = 0; // Node num of return path outlet + int OutletRetPathCompNum = 0; // Index to return path component number for outlet node Array1D_string ComponentType; // TODO: Convert this from string to enum and remove ComponentTypeEnum below Array1D ComponentTypeEnum; Array1D_string ComponentName; Array1D_int ComponentIndex; - - // Default Constructor - ReturnAir() : NumOfComponents(0), OutletNodeNum(0) - { - } }; void GetZoneEquipmentData(EnergyPlusData &state); diff --git a/src/EnergyPlus/GeneralRoutines.cc b/src/EnergyPlus/GeneralRoutines.cc index 9eac4560c9c..4784ac71328 100644 --- a/src/EnergyPlus/GeneralRoutines.cc +++ b/src/EnergyPlus/GeneralRoutines.cc @@ -1298,6 +1298,9 @@ void TestReturnAirPathIntegrity(EnergyPlusData &state, bool &ErrFound, Array2S_i } else { ++CountNodes; AllNodes(CountNodes) = state.dataMixerComponent->MixerCond(Count2).OutletNode; + if (state.dataZoneEquip->ReturnAirPath(BCount).OutletNodeNum == state.dataMixerComponent->MixerCond(Count2).OutletNode) { + state.dataZoneEquip->ReturnAirPath(BCount).OutletRetPathCompNum = NumComp; + } for (int Loop = 1; Loop <= state.dataMixerComponent->MixerCond(Count2).NumInletNodes; ++Loop) { ++CountNodes; AllNodes(CountNodes) = state.dataMixerComponent->MixerCond(Count2).InletNode(Loop); @@ -1336,6 +1339,9 @@ void TestReturnAirPathIntegrity(EnergyPlusData &state, bool &ErrFound, Array2S_i } else { ++CountNodes; AllNodes(CountNodes) = state.dataZonePlenum->ZoneRetPlenCond(Count2).OutletNode; + if (state.dataZoneEquip->ReturnAirPath(BCount).OutletNodeNum == state.dataZonePlenum->ZoneRetPlenCond(Count2).OutletNode) { + state.dataZoneEquip->ReturnAirPath(BCount).OutletRetPathCompNum = NumComp; + } for (int Loop = 1; Loop <= state.dataZonePlenum->ZoneRetPlenCond(Count2).NumInletNodes; ++Loop) { ++CountNodes; AllNodes(CountNodes) = state.dataZonePlenum->ZoneRetPlenCond(Count2).InletNode(Loop); diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 441e165bb10..8c5ecf9cae4 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -931,9 +931,9 @@ namespace OutputReportPredefined { s->pdchTopAirSupplyDuctType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Branch Type"); s->pdchTopAirSupplyPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Type"); s->pdchTopAirSupplyPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Supply Path Component Name"); - s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); s->pdchTopAirTermUnitType = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Type"); s->pdchTopAirTermUnitName = newPreDefColumn(state, s->pdstTopAirDemand, "Terminal Unit Name"); + s->pdchTopAirZoneName = newPreDefColumn(state, s->pdstTopAirDemand, "Zone Name"); s->pdchTopAirReturnPCompType = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Type"); s->pdchTopAirReturnPCompName = newPreDefColumn(state, s->pdstTopAirDemand, "Return Path Component Name"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 4993680d366..a946396a95b 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -904,9 +904,9 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopAirSupplyDuctType = 0; int pdchTopAirSupplyPCompType = 0; int pdchTopAirSupplyPCompName = 0; - int pdchTopAirZoneName = 0; int pdchTopAirTermUnitType = 0; int pdchTopAirTermUnitName = 0; + int pdchTopAirZoneName = 0; int pdchTopAirReturnPCompType = 0; int pdchTopAirReturnPCompName = 0; diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc index 88fc5fabb8d..0e08bfccd38 100644 --- a/src/EnergyPlus/SimAirServingZones.cc +++ b/src/EnergyPlus/SimAirServingZones.cc @@ -1582,6 +1582,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE ++SupAirPathOutNodeNum; // map the outlet node number to the HVAC (global) node number state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNode(SupAirPathOutNodeNum) = supNode(SupNodeIndex); + state.dataZoneEquip->SupplyAirPath(SupAirPath).OutletNodeSupplyPathCompNum(SupAirPathOutNodeNum) = supNodeCompNum(SupNodeIndex); } } } @@ -2333,6 +2334,8 @@ void ConnectReturnNodes(EnergyPlusData &state) for (int inNode = 1; inNode <= thisMixer.NumInletNodes; ++inNode) { if (thisReturnNode == thisMixer.InletNode(inNode)) { thisZoneEquip.ReturnNodeAirLoopNum(zoneOutNum) = airLoopNum; // set the return node airloop num + thisZoneEquip.ReturnNodeRetPathNum(zoneOutNum) = retPathNum; + thisZoneEquip.ReturnNodeRetPathCompNum(zoneOutNum) = compNum; returnPathFound = true; break; // leave component inlet node loop } @@ -2342,6 +2345,8 @@ void ConnectReturnNodes(EnergyPlusData &state) for (int inNode = 1; inNode <= thisPlenum.NumInletNodes; ++inNode) { if (thisReturnNode == thisPlenum.InletNode(inNode)) { thisZoneEquip.ReturnNodeAirLoopNum(zoneOutNum) = airLoopNum; // set the return node airloop num + thisZoneEquip.ReturnNodeRetPathNum(zoneOutNum) = retPathNum; + thisZoneEquip.ReturnNodeRetPathCompNum(zoneOutNum) = compNum; returnPathFound = true; break; // leave component inlet node loop } diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 39d4dbd91dc..706d5156423 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -156,6 +156,7 @@ void InitEnergyReports(EnergyPlusData &state) if (thisZoneEquipConfig.AirDistUnitCool(ZoneInletNodeNum).InNode == state.dataZoneEquip->SupplyAirPath(SAPNum).OutletNode(SAPOutNode)) { thisZoneEquipConfig.AirDistUnitCool(ZoneInletNodeNum).SupplyAirPathIndex = SAPNum; + thisZoneEquipConfig.AirDistUnitCool(ZoneInletNodeNum).SupplyAirPathOutNodeIndex = SAPOutNode; for (int OutNum = 1; OutNum <= state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumSupplyNodes; ++OutNum) { if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).ZoneEquipSupplyNodeNum(OutNum) == @@ -224,6 +225,7 @@ void InitEnergyReports(EnergyPlusData &state) if (thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).InNode == state.dataZoneEquip->SupplyAirPath(SAPNum).OutletNode(SAPOutNode)) { thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathIndex = SAPNum; + thisZoneEquipConfig.AirDistUnitHeat(ZoneInletNodeNum).SupplyAirPathOutNodeIndex = SAPOutNode; for (int OutNum = 1; OutNum <= state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumSupplyNodes; ++OutNum) { if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).ZoneEquipSupplyNodeNum(OutNum) == @@ -4852,21 +4854,6 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &thisAtoZInfo = state.dataAirLoop->AirToZoneNodeInfo(airLoopNum); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); ++rowCounter; - if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { - auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); - auto &thisBranch = pas.Branch(pas.InletBranchNum[0]); - for (int compNum = 1; compNum <= thisReturnPath.NumOfComponents; ++compNum) { - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirReturnPCompType, format("{}", rowCounter), thisReturnPath.ComponentType(compNum)); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirReturnPCompName, format("{}", rowCounter), thisReturnPath.ComponentName(compNum)); - ++rowCounter; - } - } for (int ductNum = 1; ductNum <= thisAtoZInfo.NumSupplyNodes; ++ductNum) { auto &thisBranch = pas.Branch(thisAtoZInfo.SupplyDuctBranchNum(ductNum)); if (thisAtoZInfo.SupplyAirPathNum(ductNum) > 0) { @@ -4888,6 +4875,13 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); for (auto &thisCoolADU : thisZoneEquipConfig.AirDistUnitCool) { if (thisCoolADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; + if (thisCoolADU.SupplyAirPathExists) { + int spCompNum = thisSupplyPath.OutletNodeSupplyPathCompNum(thisCoolADU.SupplyAirPathOutNodeIndex); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompType, format("{}", rowCounter), thisSupplyPath.ComponentType(spCompNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompName, format("{}", rowCounter), thisSupplyPath.ComponentName(spCompNum)); + } OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry( @@ -4907,6 +4901,25 @@ void reportAirLoopToplogy(EnergyPlusData &state) orp->pdchTopAirTermUnitName, format("{}", rowCounter), state.dataDefineEquipment->AirDistUnit(aduIndex).EquipName(1)); + if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { + auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); + for (int retNodeNum = 1; retNodeNum <= thisZoneEquipConfig.NumReturnNodes; ++retNodeNum) { + if (thisZoneEquipConfig.ReturnNodeAirLoopNum(retNodeNum) == airLoopNum) { + int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathNum(retNodeNum); + if (retPathCompNum > 0) { + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirReturnPCompType, + format("{}", rowCounter), + thisReturnPath.ComponentType(retPathCompNum)); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirReturnPCompName, + format("{}", rowCounter), + thisReturnPath.ComponentName(retPathCompNum)); + } + break; + } + } + } ++rowCounter; } } @@ -4916,6 +4929,13 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); for (auto &thisHeatADU : thisZoneEquipConfig.AirDistUnitHeat) { if (thisHeatADU.SupplyBranchIndex != thisAtoZInfo.SupplyDuctBranchNum(ductNum)) continue; + if (thisHeatADU.SupplyAirPathExists) { + int spCompNum = thisSupplyPath.OutletNodeSupplyPathCompNum(thisHeatADU.SupplyAirPathOutNodeIndex); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompType, format("{}", rowCounter), thisSupplyPath.ComponentType(spCompNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyPCompName, format("{}", rowCounter), thisSupplyPath.ComponentName(spCompNum)); + } OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry( @@ -4935,6 +4955,22 @@ void reportAirLoopToplogy(EnergyPlusData &state) orp->pdchTopAirTermUnitName, format("{}", rowCounter), state.dataDefineEquipment->AirDistUnit(aduIndex).EquipName(1)); + if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { + auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); + for (int retNodeNum = 1; retNodeNum <= thisZoneEquipConfig.NumReturnNodes; ++retNodeNum) { + int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathNum(retNodeNum); + if (retPathCompNum > 0) { + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirReturnPCompType, + format("{}", rowCounter), + thisReturnPath.ComponentType(retPathCompNum)); + OutputReportPredefined::PreDefTableEntry(state, + orp->pdchTopAirReturnPCompName, + format("{}", rowCounter), + thisReturnPath.ComponentName(retPathCompNum)); + } + } + } ++rowCounter; } } @@ -4948,6 +4984,23 @@ void reportAirLoopToplogy(EnergyPlusData &state) ++rowCounter; } } + if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { + auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); + for (int compNum = 1; compNum <= thisReturnPath.NumOfComponents; ++compNum) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); + if (compNum == thisReturnPath.OutletRetPathCompNum) { + auto &thisBranch = pas.Branch(pas.InletBranchNum[0]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + } + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirReturnPCompType, format("{}", rowCounter), thisReturnPath.ComponentType(compNum)); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirReturnPCompName, format("{}", rowCounter), thisReturnPath.ComponentName(compNum)); + ++rowCounter; + } + } } } From fe3e68f27dd9a41578c18dd998f49ba88ee204f4 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 2 Apr 2024 17:03:02 -0500 Subject: [PATCH 047/115] Delete unused function --- src/EnergyPlus/ReturnAirPathManager.cc | 15 --------------- src/EnergyPlus/ReturnAirPathManager.hh | 2 -- 2 files changed, 17 deletions(-) diff --git a/src/EnergyPlus/ReturnAirPathManager.cc b/src/EnergyPlus/ReturnAirPathManager.cc index 688d92ed54f..701d2edc1f0 100644 --- a/src/EnergyPlus/ReturnAirPathManager.cc +++ b/src/EnergyPlus/ReturnAirPathManager.cc @@ -209,21 +209,6 @@ namespace ReturnAirPathManager { } } - void InitReturnAirPath([[maybe_unused]] int &ReturnAirPathNum) // unused1208 - { - // SUBROUTINE INFORMATION: - // AUTHOR: Russ Taylor - // DATE WRITTEN: Nov 1997 - - // PURPOSE OF THIS SUBROUTINE: This subroutine - - // METHODOLOGY EMPLOYED: - - // REFERENCES: - - // USE STATEMENTS: - } - void CalcReturnAirPath(EnergyPlusData &state, int &ReturnAirPathNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/ReturnAirPathManager.hh b/src/EnergyPlus/ReturnAirPathManager.hh index c3c6ac16dbe..62bf14d0933 100644 --- a/src/EnergyPlus/ReturnAirPathManager.hh +++ b/src/EnergyPlus/ReturnAirPathManager.hh @@ -63,8 +63,6 @@ namespace ReturnAirPathManager { void GetReturnAirPathInput(EnergyPlusData &state); - void InitReturnAirPath(int &ReturnAirPathNum); // unused1208 - void CalcReturnAirPath(EnergyPlusData &state, int &ReturnAirPathNum); void ReportReturnAirPath(int &ReturnAirPathNum); // unused1208 From 5fa091cc2f08abcad5f5f167c2096753f43c3771 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 3 Apr 2024 09:33:12 -0500 Subject: [PATCH 048/115] format --- src/EnergyPlus/Plant/PlantManager.hh | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/EnergyPlus/Plant/PlantManager.hh b/src/EnergyPlus/Plant/PlantManager.hh index 2274d8a263c..1c07cdacab0 100644 --- a/src/EnergyPlus/Plant/PlantManager.hh +++ b/src/EnergyPlus/Plant/PlantManager.hh @@ -91,19 +91,19 @@ namespace PlantManager { // const int reportOffset); void fillPlantToplogySplitterRow2(EnergyPlusData &state, - const std::string_view &loopType, - const std::string_view &loopName, - const std::string_view &side, - const std::string_view &splitterName, - int &rowCounter); - - void fillPlantToplogyMixerRow2(EnergyPlusData &state, const std::string_view &loopType, const std::string_view &loopName, const std::string_view &side, - const std::string_view &mixerName, + const std::string_view &splitterName, int &rowCounter); + void fillPlantToplogyMixerRow2(EnergyPlusData &state, + const std::string_view &loopType, + const std::string_view &loopName, + const std::string_view &side, + const std::string_view &mixerName, + int &rowCounter); + void fillPlantToplogyComponentRow2(EnergyPlusData &state, const std::string_view &loopType, const std::string_view &loopName, From c486077c1cfb937a107f8ba7afa1a9f0f4ae6f4a Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 3 Apr 2024 12:13:21 -0500 Subject: [PATCH 049/115] Fix retPathCompNum --- src/EnergyPlus/SystemReports.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 706d5156423..ad0f391fb3a 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4905,7 +4905,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); for (int retNodeNum = 1; retNodeNum <= thisZoneEquipConfig.NumReturnNodes; ++retNodeNum) { if (thisZoneEquipConfig.ReturnNodeAirLoopNum(retNodeNum) == airLoopNum) { - int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathNum(retNodeNum); + int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathCompNum(retNodeNum); if (retPathCompNum > 0) { OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirReturnPCompType, @@ -4958,7 +4958,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) if (thisAtoZInfo.ReturnAirPathNum(1) > 0) { auto &thisReturnPath = state.dataZoneEquip->ReturnAirPath(thisAtoZInfo.ReturnAirPathNum(1)); for (int retNodeNum = 1; retNodeNum <= thisZoneEquipConfig.NumReturnNodes; ++retNodeNum) { - int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathNum(retNodeNum); + int retPathCompNum = thisZoneEquipConfig.ReturnNodeRetPathCompNum(retNodeNum); if (retPathCompNum > 0) { OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirReturnPCompType, From a80d41c965231b8db6452b2e4e4164ab68faac45 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 4 Apr 2024 05:52:22 -0500 Subject: [PATCH 050/115] Add PIU_reportTerminalUnit unit test. --- .../unit/PoweredInductionUnits.unit.cc | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc index 116de366ef5..d12648ceb35 100644 --- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc +++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc @@ -1964,3 +1964,60 @@ TEST_F(EnergyPlusFixture, PIU_InducedAir_Plenums) }); EXPECT_TRUE(compare_err_stream(expectedError, true)); } + +TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) +{ + using namespace EnergyPlus::OutputReportPredefined; + auto &orp = *state->dataOutRptPredefined; + + SetPredefinedTables(*state); + + state->dataScheduleMgr->ScheduleInputProcessed = true; + auto &sch = state->dataScheduleMgr->Schedule; + sch.allocate(5); + sch(1).Name = "schA"; + sch(2).Name = "schB"; + + auto &adu = state->dataDefineEquipment->AirDistUnit; + adu.allocate(2); + adu(1).Name = "ADU a"; + adu(1).TermUnitSizingNum = 1; + + auto &siz = state->dataSize->TermUnitFinalZoneSizing; + siz.allocate(2); + siz(1).DesCoolVolFlowMin = 0.15; + siz(1).MinOA = 0.05; + siz(1).CoolDesTemp = 12.5; + siz(1).HeatDesTemp = 40.0; + siz(1).DesHeatLoad = 2000.0; + siz(1).DesCoolLoad = 3000.0; + + auto &piu = state->dataPowerInductionUnits->PIU; + piu.allocate(2); + piu(1).ADUNum = 1; + piu(1).UnitType = "AirTerminal:SingleDuct:SeriesPIU:Reheat"; + piu(1).MaxPriAirVolFlow = 0.30; + piu(1).MaxSecAirVolFlow = 0.25; + piu(1).HCoilType = PoweredInductionUnits::HtgCoilType::Electric; + piu(1).Fan_Num = 1; + piu(1).FanName = "FanA"; + + piu(1).reportTerminalUnit(*state); + + EXPECT_EQ("0.15", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlow, "ADU a")); + EXPECT_EQ("0.05", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOutdoorFlow, "ADU a")); + EXPECT_EQ("12.50", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupCoolingSP, "ADU a")); + EXPECT_EQ("40.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermSupHeatingSP, "ADU a")); + EXPECT_EQ("2000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatingCap, "ADU a")); + EXPECT_EQ("3000.00", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolingCap, "ADU a")); + EXPECT_EQ("AirTerminal:SingleDuct:SeriesPIU:Reheat", RetrievePreDefTableEntry(*state, orp.pdchAirTermTypeInp, "ADU a")); + EXPECT_EQ("0.30", RetrievePreDefTableEntry(*state, orp.pdchAirTermPrimFlow, "ADU a")); + EXPECT_EQ("0.25", RetrievePreDefTableEntry(*state, orp.pdchAirTermSecdFlow, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); + EXPECT_EQ("COIL:HEATING:ELECTRIC", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); + EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); + EXPECT_EQ("FAN:VARIABLEVOLUME", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("FanA", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); +} From 688a553dece19b19152b586852dc9c3e80f2bf66 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 5 Apr 2024 12:53:29 -0500 Subject: [PATCH 051/115] Clang formatting --- tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc | 1 - tst/EnergyPlus/unit/Construction.unit.cc | 6 +----- tst/EnergyPlus/unit/HVACCooledBeam.unit.cc | 4 +--- tst/EnergyPlus/unit/SingleDuct.unit.cc | 2 +- 4 files changed, 3 insertions(+), 10 deletions(-) diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc index 44b4d8c4fd3..5491899e1b5 100644 --- a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc @@ -1883,5 +1883,4 @@ TEST_F(EnergyPlusFixture, SingleDuctInduction_reportTerminalUnit) EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); } - } // namespace EnergyPlus diff --git a/tst/EnergyPlus/unit/Construction.unit.cc b/tst/EnergyPlus/unit/Construction.unit.cc index b2fa78756b9..9f7a226dbb7 100644 --- a/tst/EnergyPlus/unit/Construction.unit.cc +++ b/tst/EnergyPlus/unit/Construction.unit.cc @@ -52,15 +52,14 @@ // EnergyPlus Headers #include -#include #include +#include #include "Fixtures/EnergyPlusFixture.hh" using namespace EnergyPlus; using namespace EnergyPlus::Construction; - TEST_F(EnergyPlusFixture, Construction_reportLayers) { using namespace EnergyPlus::OutputReportPredefined; @@ -108,7 +107,6 @@ TEST_F(EnergyPlusFixture, Construction_reportLayers) c->Construct(3).LayerPoint(2) = 1; c->Construct(3).reportLayers(*state); - EXPECT_EQ("mat b", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[0], "ConsB")); EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[1], "ConsB")); @@ -123,5 +121,3 @@ TEST_F(EnergyPlusFixture, Construction_reportLayers) EXPECT_EQ("mat a", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[1], "ConsDA")); EXPECT_EQ("NOT FOUND", RetrievePreDefTableEntry(*state, orp.pdchOpqConsLayCol[2], "ConsDA")); } - - diff --git a/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc b/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc index 039197aad69..82dabd45c5b 100644 --- a/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc +++ b/tst/EnergyPlus/unit/HVACCooledBeam.unit.cc @@ -53,20 +53,18 @@ // EnergyPlus Headers #include #include -#include #include #include #include +#include #include - #include "Fixtures/EnergyPlusFixture.hh" using namespace EnergyPlus; using namespace EnergyPlus::HVACCooledBeam; using namespace EnergyPlus::DataPlant; - TEST_F(EnergyPlusFixture, HVACCooledBeam_reportTerminalUnit) { using namespace EnergyPlus::OutputReportPredefined; diff --git a/tst/EnergyPlus/unit/SingleDuct.unit.cc b/tst/EnergyPlus/unit/SingleDuct.unit.cc index efef8515537..74bc45c9dd0 100644 --- a/tst/EnergyPlus/unit/SingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/SingleDuct.unit.cc @@ -57,8 +57,8 @@ #include #include #include -#include #include +#include #include #include #include From a3ec467680cff99de385201dfced93fbb1502021 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 5 Apr 2024 13:16:35 -0500 Subject: [PATCH 052/115] Fix missing header in HVACCooledBeam.hh --- src/EnergyPlus/HVACCooledBeam.hh | 1 + 1 file changed, 1 insertion(+) diff --git a/src/EnergyPlus/HVACCooledBeam.hh b/src/EnergyPlus/HVACCooledBeam.hh index f9157b510db..05be8e410bb 100644 --- a/src/EnergyPlus/HVACCooledBeam.hh +++ b/src/EnergyPlus/HVACCooledBeam.hh @@ -55,6 +55,7 @@ #include #include #include +#include namespace EnergyPlus { From fe5e3b5eba0fabf806c04c029935f13f46cb47f4 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 5 Apr 2024 15:31:12 -0500 Subject: [PATCH 053/115] Fix fan reference in PIU_reportTerminalUnit --- tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc index d12648ceb35..e0a4edb93e7 100644 --- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc +++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc @@ -1999,7 +1999,7 @@ TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) piu(1).MaxPriAirVolFlow = 0.30; piu(1).MaxSecAirVolFlow = 0.25; piu(1).HCoilType = PoweredInductionUnits::HtgCoilType::Electric; - piu(1).Fan_Num = 1; + piu(1).Fan_Num = DataHVACGlobals::FanType_SimpleConstVolume; piu(1).FanName = "FanA"; piu(1).reportTerminalUnit(*state); @@ -2018,6 +2018,6 @@ TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); EXPECT_EQ("COIL:HEATING:ELECTRIC", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); - EXPECT_EQ("FAN:VARIABLEVOLUME", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("Fan:ConstantVolume", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); EXPECT_EQ("FanA", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); } From cf7054ba94f455776b5a411ffc53f8846d571502 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 8 Apr 2024 09:39:15 -0500 Subject: [PATCH 054/115] Format fix. --- tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc index 7fdcbe36508..095494026a4 100644 --- a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc +++ b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc @@ -1698,7 +1698,6 @@ TEST_F(EnergyPlusFixture, DownInterpolate4HistoryValues_Test) EXPECT_NEAR(oldValue[3], DSHistoryValue4, 0.000001); } - TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) { using namespace EnergyPlus::OutputReportPredefined; From a75ca30ce216547a25629a7eedba09d500336c76 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Thu, 25 Apr 2024 15:53:35 -0500 Subject: [PATCH 055/115] Merge cleanup --- src/EnergyPlus/DataHVACGlobals.hh | 1 - src/EnergyPlus/OutdoorAirUnit.hh | 4 ++-- src/EnergyPlus/PoweredInductionUnits.cc | 2 +- src/EnergyPlus/SingleDuct.cc | 6 +++++- tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc | 2 +- tst/EnergyPlus/unit/SingleDuct.unit.cc | 8 ++++---- 6 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/EnergyPlus/DataHVACGlobals.hh b/src/EnergyPlus/DataHVACGlobals.hh index d2fddc86714..361040688ba 100644 --- a/src/EnergyPlus/DataHVACGlobals.hh +++ b/src/EnergyPlus/DataHVACGlobals.hh @@ -415,7 +415,6 @@ namespace DataHVACGlobals { int constexpr MaxSpeedLevels = 10; - // extern Array1D_string const cFanTypes; extern Array1D_string const cAllCoilTypes; extern Array1D_string const cCoolingCoilTypes; extern Array1D_string const cHeatingCoilTypes; diff --git a/src/EnergyPlus/OutdoorAirUnit.hh b/src/EnergyPlus/OutdoorAirUnit.hh index eff657d24a4..62f9432c88d 100644 --- a/src/EnergyPlus/OutdoorAirUnit.hh +++ b/src/EnergyPlus/OutdoorAirUnit.hh @@ -185,7 +185,7 @@ namespace OutdoorAirUnit { int AirOutletNode; // outlet air node number std::string SFanName; // name of supply fan int SFan_Index; // index in fan structure - DataHVACGlobals::FanType supFanType; // type of fan in cFanTypes + DataHVACGlobals::FanType supFanType; // type of fan in fanTypeNames int SFanAvailSchedPtr; // supply fan availability sched from fan object DataHVACGlobals::FanPlace supFanPlace; // fan placement; blow through and draw through Real64 FanCorTemp; // correction temperature @@ -193,7 +193,7 @@ namespace OutdoorAirUnit { int SFanOutletNode; // supply fan outlet node number std::string ExtFanName; // name of exhaust fan int ExtFan_Index; // index in fan structure - DataHVACGlobals::FanType extFanType; // type of fan in cFanTypes + DataHVACGlobals::FanType extFanType; // type of fan in fanTypeNames int ExtFanAvailSchedPtr; // exhaust fan availability sched from fan object bool ExtFan; // true if there is an exhaust fan std::string OutAirSchedName; // schedule of fraction for outside air (all controls) diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 6b713803f7c..305960bf0e8 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -2192,7 +2192,7 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HCoilNamesUC[(int)this->HCoilType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::cFanTypes((int)this->Fan_Num)); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNames[(int)this->fanType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 5a79c9b0ad5..87b69a6aeba 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -6523,7 +6523,11 @@ void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, schName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->ReheatComp); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, this->FanType); + if ((int)this->fanType >= 0) { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNames[(int)this->fanType]); + } else { + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); + } OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc index 9cd89e64bd6..046704ef7f4 100644 --- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc +++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc @@ -1999,7 +1999,7 @@ TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) piu(1).MaxPriAirVolFlow = 0.30; piu(1).MaxSecAirVolFlow = 0.25; piu(1).HCoilType = PoweredInductionUnits::HtgCoilType::Electric; - piu(1).Fan_Num = DataHVACGlobals::FanType_SimpleConstVolume; + piu(1).fanType = DataHVACGlobals::FanType::Constant; piu(1).FanName = "FanA"; piu(1).reportTerminalUnit(*state); diff --git a/tst/EnergyPlus/unit/SingleDuct.unit.cc b/tst/EnergyPlus/unit/SingleDuct.unit.cc index 74bc45c9dd0..a961889d0b4 100644 --- a/tst/EnergyPlus/unit/SingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/SingleDuct.unit.cc @@ -3053,7 +3053,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) sdat(1).MaxAirVolFlowRateDuringReheat = 0.25; sdat(1).OARequirementsPtr = 0; sdat(1).ReheatComp = "watercoil"; - sdat(1).FanType = "variable"; + sdat(1).fanType = DataHVACGlobals::FanType::VAV; sdat(1).FanName = "FanA"; sdat(1).reportTerminalUnit(*state); @@ -3072,7 +3072,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a")); EXPECT_EQ("watercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a")); EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a")); - EXPECT_EQ("variable", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); + EXPECT_EQ("Fan:VariableVolume", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a")); EXPECT_EQ("FanA", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a")); adu(2).Name = "ADU b"; @@ -3092,7 +3092,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) sdat(2).MaxAirVolFlowRateDuringReheat = 0.26; sdat(2).OARequirementsPtr = 1; sdat(2).ReheatComp = "furncoil"; - sdat(2).FanType = "single"; + sdat(2).fanType = DataHVACGlobals::FanType::OnOff; sdat(2).FanName = "FanB"; auto &oa = state->dataSize->OARequirements; @@ -3115,6 +3115,6 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) EXPECT_EQ("schB", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU b")); EXPECT_EQ("furncoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU b")); EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU b")); - EXPECT_EQ("single", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU b")); + EXPECT_EQ("Fan:OnOff", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU b")); EXPECT_EQ("FanB", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU b")); } From 88b93956753c430a4a109ea103be3bc1df7ef46c Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 7 May 2024 15:04:10 -0500 Subject: [PATCH 056/115] Merge repairs --- src/EnergyPlus/Fans.cc | 484 +++++++++--------- src/EnergyPlus/PoweredInductionUnits.cc | 2 +- src/EnergyPlus/SingleDuct.cc | 2 +- src/EnergyPlus/SystemReports.cc | 18 +- src/EnergyPlus/SystemReports.hh | 2 +- src/EnergyPlus/ZoneTempPredictorCorrector.cc | 10 +- .../unit/PoweredInductionUnits.unit.cc | 2 +- tst/EnergyPlus/unit/SingleDuct.unit.cc | 4 +- .../unit/ZoneTempPredictorCorrector.unit.cc | 8 +- 9 files changed, 268 insertions(+), 264 deletions(-) diff --git a/src/EnergyPlus/Fans.cc b/src/EnergyPlus/Fans.cc index adcbbd44738..c21b58750b4 100644 --- a/src/EnergyPlus/Fans.cc +++ b/src/EnergyPlus/Fans.cc @@ -132,19 +132,19 @@ void FanBase::simulate(EnergyPlusData &state, case HVAC::FanType::Constant: { _thisFan->simulateConstant(state); - } break; + } break; case HVAC::FanType::VAV: { _thisFan->simulateVAV(state, _pressureRise); - } break; + } break; case HVAC::FanType::OnOff: { _thisFan->simulateOnOff(state, _speedRatio); - } break; + } break; case HVAC::FanType::Exhaust: { _thisFan->simulateZoneExhaust(state); - } break; + } break; case HVAC::FanType::ComponentModel: { _thisFan->simulateComponentModel(state); - } break; + } break; default: { } break; } // switch (type) @@ -174,7 +174,7 @@ void FanBase::simulate(EnergyPlusData &state, _thisFan->calcSimpleSystemFan(state, _flowFraction, _, _, _, _, _, _); } else { _thisFan->calcSimpleSystemFan(state, _, _, _, _, _, _, _); - } + } } update(state); @@ -200,7 +200,7 @@ void GetFanInput(EnergyPlusData &state) int NumAlphas; int NumNums; int IOStat; - bool ErrorsFound(false); // If errors detected in input + bool ErrorsFound(false); // If errors detected in input Array1D_string cAlphaFieldNames; Array1D_string cNumericFieldNames; Array1D_bool lNumericFieldBlanks; @@ -272,17 +272,17 @@ void GetFanInput(EnergyPlusData &state) for (int SimpFanNum = 1; SimpFanNum <= NumSimpFan; ++SimpFanNum) { cCurrentModuleObject = "Fan:ConstantVolume"; ip->getObjectItem(state, - cCurrentModuleObject, - SimpFanNum, - cAlphaArgs, - NumAlphas, - rNumericArgs, - NumNums, - IOStat, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cCurrentModuleObject, + SimpFanNum, + cAlphaArgs, + NumAlphas, + rNumericArgs, + NumNums, + IOStat, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFieldNames, + cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; @@ -304,8 +304,8 @@ void GetFanInput(EnergyPlusData &state) fan->availSchedNum = ScheduleManager::ScheduleAlwaysOn; } else if ((fan->availSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(2))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2)); - ErrorsFound = true; - } + ErrorsFound = true; + } fan->totalEff = rNumericArgs(1); fan->deltaPress = rNumericArgs(2); @@ -321,23 +321,23 @@ void GetFanInput(EnergyPlusData &state) fan->minAirFlowRate = 0.0; fan->inletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(3), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanConstantVolume, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Inlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(3), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanConstantVolume, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(4), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanConstantVolume, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Outlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(4), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanConstantVolume, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->endUseSubcategoryName = (NumAlphas > 4) ? cAlphaArgs(5) : "General"; @@ -383,8 +383,8 @@ void GetFanInput(EnergyPlusData &state) fan->availSchedNum = ScheduleManager::ScheduleAlwaysOn; } else if ((fan->availSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(2))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2)); - ErrorsFound = true; - } + ErrorsFound = true; + } fan->totalEff = rNumericArgs(1); fan->deltaPress = rNumericArgs(2); @@ -414,23 +414,23 @@ void GetFanInput(EnergyPlusData &state) ShowContinueError(state, format("For {}, Fan={}", cCurrentModuleObject, cAlphaArgs(1))); } fan->inletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(4), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanVariableVolume, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Inlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(4), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanVariableVolume, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(5), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanVariableVolume, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Outlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(5), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanVariableVolume, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->endUseSubcategoryName = (NumAlphas > 5) ? cAlphaArgs(6) : "General"; @@ -444,17 +444,17 @@ void GetFanInput(EnergyPlusData &state) for (int ExhFanNum = 1; ExhFanNum <= NumZoneExhFan; ++ExhFanNum) { cCurrentModuleObject = "Fan:ZoneExhaust"; ip->getObjectItem(state, - cCurrentModuleObject, - ExhFanNum, - cAlphaArgs, - NumAlphas, - rNumericArgs, - NumNums, - IOStat, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cCurrentModuleObject, + ExhFanNum, + cAlphaArgs, + NumAlphas, + rNumericArgs, + NumNums, + IOStat, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFieldNames, + cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; @@ -476,14 +476,14 @@ void GetFanInput(EnergyPlusData &state) fan->availSchedNum = ScheduleManager::ScheduleAlwaysOn; } else if ((fan->availSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(2))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2)); - ErrorsFound = true; + ErrorsFound = true; } else if (ScheduleManager::HasFractionalScheduleValue(state, fan->availSchedNum)) { - ShowWarningError(state, - format("{}=\"{}\" has fractional values in Schedule={}. Only 0.0 in the schedule value turns the fan off.", - cCurrentModuleObject, + ShowWarningError(state, + format("{}=\"{}\" has fractional values in Schedule={}. Only 0.0 in the schedule value turns the fan off.", + cCurrentModuleObject, fan->Name, - cAlphaArgs(2))); - } + cAlphaArgs(2))); + } fan->totalEff = rNumericArgs(1); fan->deltaPress = rNumericArgs(2); @@ -502,23 +502,23 @@ void GetFanInput(EnergyPlusData &state) } fan->inletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(3), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanZoneExhaust, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Inlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(3), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanZoneExhaust, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(4), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanZoneExhaust, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Outlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(4), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanZoneExhaust, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->endUseSubcategoryName = (NumAlphas > 4 && !lAlphaFieldBlanks(5)) ? cAlphaArgs(5) : "General"; @@ -526,78 +526,78 @@ void GetFanInput(EnergyPlusData &state) fan->flowFracSchedNum = ScheduleManager::ScheduleAlwaysOn; } else if ((fan->flowFracSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(6))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(6), cAlphaArgs(6)); - ErrorsFound = true; + ErrorsFound = true; } else if (!ScheduleManager::CheckScheduleValueMinMax( state, fan->flowFracSchedNum, ScheduleManager::Clusivity::Inclusive, 0.0, ScheduleManager::Clusivity::Inclusive, 1.0)) { ShowSevereError( state, format("{}: {}: invalid {} for {}={}", routineName, cCurrentModuleObject, cAlphaFieldNames(6), cAlphaFieldNames(1), cAlphaArgs(1))); - ShowContinueError(state, format("Error found in {} = {}", cAlphaFieldNames(6), cAlphaArgs(6))); - ShowContinueError(state, "Schedule values must be (>=0., <=1.)"); - ErrorsFound = true; - } + ShowContinueError(state, format("Error found in {} = {}", cAlphaFieldNames(6), cAlphaArgs(6))); + ShowContinueError(state, "Schedule values must be (>=0., <=1.)"); + ErrorsFound = true; + } if (NumAlphas <= 6 || lAlphaFieldBlanks(7)) { fan->availManagerMode = AvailManagerMode::Coupled; } else if ((fan->availManagerMode = static_cast(getEnumValue(availManagerModeNamesUC, cAlphaArgs(7)))) == AvailManagerMode::Invalid) { ShowSevereInvalidKey(state, eoh, cAlphaFieldNames(7), cAlphaArgs(7)); - ErrorsFound = true; - } + ErrorsFound = true; + } if (NumAlphas <= 7 || lAlphaFieldBlanks(8)) { fan->minTempLimitSchedNum = 0; } else if ((fan->minTempLimitSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(8))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(8), cAlphaArgs(8)); - ErrorsFound = true; - } + ErrorsFound = true; + } if (NumAlphas <= 8 || lAlphaFieldBlanks(9)) { fan->balancedFractSchedNum = 0; } else if (state.dataHeatBal->ZoneAirMassFlow.ZoneFlowAdjustment != DataHeatBalance::AdjustmentType::NoAdjustReturnAndMixing) { - // do not include adjusted for "balanced" exhaust flow in the zone total return calculation - ShowWarningError(state, + // do not include adjusted for "balanced" exhaust flow in the zone total return calculation + ShowWarningError(state, format("{}: {}: invalid {} = {} for {}={}", routineName, - cCurrentModuleObject, - cAlphaFieldNames(9), - cAlphaArgs(9), - cAlphaFieldNames(1), - cAlphaArgs(1))); - ShowContinueError(state, "When zone air mass flow balance is enforced, this input field should be left blank."); - ShowContinueError(state, "This schedule will be ignored in the simulation."); + cCurrentModuleObject, + cAlphaFieldNames(9), + cAlphaArgs(9), + cAlphaFieldNames(1), + cAlphaArgs(1))); + ShowContinueError(state, "When zone air mass flow balance is enforced, this input field should be left blank."); + ShowContinueError(state, "This schedule will be ignored in the simulation."); fan->balancedFractSchedNum = 0; } else if ((fan->balancedFractSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(9))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(9), cAlphaArgs(9)); - ErrorsFound = true; + ErrorsFound = true; } else if (!ScheduleManager::CheckScheduleValueMinMax( state, fan->balancedFractSchedNum, ScheduleManager::Clusivity::Inclusive, 0.0, ScheduleManager::Clusivity::Inclusive, 1.0)) { ShowSevereError( state, format("{}: {}: invalid {} for {}={}", routineName, cCurrentModuleObject, cAlphaFieldNames(9), cAlphaFieldNames(1), cAlphaArgs(1))); - ShowContinueError(state, format("Error found in {} = {}", cAlphaFieldNames(9), cAlphaArgs(9))); - ShowContinueError(state, "Schedule values must be (>=0., <=1.)"); - ErrorsFound = true; - } + ShowContinueError(state, format("Error found in {} = {}", cAlphaFieldNames(9), cAlphaArgs(9))); + ShowContinueError(state, "Schedule values must be (>=0., <=1.)"); + ErrorsFound = true; + } if (ErrorsFound) { ShowFatalError(state, format("{}: Errors found in input for fan name = {}. Program terminates.", routineName, fan->Name)); - } + } } // for (iFanExhaust) for (int OnOffFanNum = 1; OnOffFanNum <= NumOnOff; ++OnOffFanNum) { cCurrentModuleObject = "Fan:OnOff"; ip->getObjectItem(state, - cCurrentModuleObject, - OnOffFanNum, - cAlphaArgs, - NumAlphas, - rNumericArgs, - NumNums, - IOStat, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cCurrentModuleObject, + OnOffFanNum, + cAlphaArgs, + NumAlphas, + rNumericArgs, + NumNums, + IOStat, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFieldNames, + cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; @@ -619,8 +619,8 @@ void GetFanInput(EnergyPlusData &state) fan->availSchedNum = ScheduleManager::ScheduleAlwaysOn; } else if ((fan->availSchedNum = ScheduleManager::GetScheduleIndex(state, cAlphaArgs(2))) == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2)); - ErrorsFound = true; - } + ErrorsFound = true; + } fan->totalEff = rNumericArgs(1); fan->deltaPress = rNumericArgs(2); @@ -641,23 +641,23 @@ void GetFanInput(EnergyPlusData &state) fan->minAirFlowRate = 0.0; fan->inletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(3), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanOnOff, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Inlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(3), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanOnOff, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(4), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanOnOff, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Outlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); + cAlphaArgs(4), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanOnOff, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); if (NumAlphas > 4 && !lAlphaFieldBlanks(5)) { fan->powerRatioAtSpeedRatioCurveNum = Curve::GetCurveIndex(state, cAlphaArgs(5)); @@ -688,21 +688,21 @@ void GetFanInput(EnergyPlusData &state) e.MaxAirMassFlowRate = 0.0; } - // input the night ventilation performance objects - for (int NVPerfNum = 1; NVPerfNum <= state.dataFans->NumNightVentPerf; ++NVPerfNum) { + // input the night ventilation performance objects + for (int NVPerfNum = 1; NVPerfNum <= state.dataFans->NumNightVentPerf; ++NVPerfNum) { cCurrentModuleObject = "FanPerformance:NightVentilation"; ip->getObjectItem(state, - cCurrentModuleObject, - NVPerfNum, - cAlphaArgs, - NumAlphas, - rNumericArgs, - NumNums, - IOStat, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cCurrentModuleObject, + NVPerfNum, + cAlphaArgs, + NumAlphas, + rNumericArgs, + NumNums, + IOStat, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFieldNames, + cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; @@ -718,29 +718,29 @@ void GetFanInput(EnergyPlusData &state) auto found = df->fanMap.find(nvp.FanName); if (found == df->fanMap.end()) { ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(1), cAlphaArgs(1)); - ErrorsFound = true; + ErrorsFound = true; } else { auto *fan = dynamic_cast(df->fans(found->second)); assert(fan != nullptr); fan->nightVentPerfNum = NVPerfNum; - } + } } // for (iNightVent) } for (int CompModelFanNum = 1; CompModelFanNum <= NumCompModelFan; ++CompModelFanNum) { cCurrentModuleObject = "Fan:ComponentModel"; ip->getObjectItem(state, - cCurrentModuleObject, - CompModelFanNum, - cAlphaArgs, - NumAlphas, - rNumericArgs, - NumNums, - IOStat, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cCurrentModuleObject, + CompModelFanNum, + cAlphaArgs, + NumAlphas, + rNumericArgs, + NumNums, + IOStat, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFieldNames, + cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; @@ -759,23 +759,23 @@ void GetFanInput(EnergyPlusData &state) fan->sizingPrefix = cNumericFieldNames(1); fan->inletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(2), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanComponentModel, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Inlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); // Air inlet node name + cAlphaArgs(2), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanComponentModel, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); // Air inlet node name fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(3), - ErrorsFound, - DataLoopNode::ConnectionObjectType::FanComponentModel, - cAlphaArgs(1), - DataLoopNode::NodeFluidType::Air, - DataLoopNode::ConnectionType::Outlet, - NodeInputManager::CompFluidStream::Primary, - DataLoopNode::ObjectIsNotParent); // Air outlet node name + cAlphaArgs(3), + ErrorsFound, + DataLoopNode::ConnectionObjectType::FanComponentModel, + cAlphaArgs(1), + DataLoopNode::NodeFluidType::Air, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + DataLoopNode::ObjectIsNotParent); // Air outlet node name BranchNodeConnections::TestCompSet(state, cCurrentModuleObject, cAlphaArgs(1), cAlphaArgs(2), cAlphaArgs(3), "Air Nodes"); @@ -847,7 +847,7 @@ void GetFanInput(EnergyPlusData &state) constexpr std::string_view cCurrentModuleObject = "Fan:SystemModel"; ip->getObjectItem(state, - cCurrentModuleObject, + cCurrentModuleObject, SystemFanNum, cAlphaArgs, NumAlphas, @@ -891,7 +891,7 @@ void GetFanInput(EnergyPlusData &state) NodeInputManager::CompFluidStream::Primary, DataLoopNode::ObjectIsNotParent); fan->outletNodeNum = NodeInputManager::GetOnlySingleNode(state, - cAlphaArgs(4), + cAlphaArgs(4), ErrorsFound, DataLoopNode::ConnectionObjectType::FanSystemModel, cAlphaArgs(1), @@ -917,8 +917,8 @@ void GetFanInput(EnergyPlusData &state) fan->deltaPress = rNumericArgs(3); if (fan->deltaPress <= 0.0) { ShowSevereError(state, format("{}: {} zero or negative, invalid entry in {}", routineName, cCurrentModuleObject, cNumericFieldNames(3))); - ErrorsFound = true; - } + ErrorsFound = true; + } fan->motorEff = rNumericArgs(4); fan->motorInAirFrac = rNumericArgs(5); fan->designElecPower = rNumericArgs(6); @@ -1026,10 +1026,10 @@ void GetFanInput(EnergyPlusData &state) // field set input does not match number of speeds, throw warning ShowSevereError(state, format("{}: {}=\"{}\", invalid entry.", routineName, cCurrentModuleObject, cAlphaArgs(1))); ShowContinueError( - state, + state, "Fan with Discrete speed control does not have input for power fraction at all speed levels and does not have a power curve."); ErrorsFound = true; - } + } } if (fan->heatLossDest == HeatLossDest::Zone) { @@ -1125,21 +1125,21 @@ void GetFanInput(EnergyPlusData &state) auto *fanExhaust = dynamic_cast(fan); assert(fanExhaust != nullptr); if (fanExhaust->balancedFractSchedNum > 0) { - SetupOutputVariable(state, - "Fan Unbalanced Air Mass Flow Rate", - Constant::Units::kg_s, + SetupOutputVariable(state, + "Fan Unbalanced Air Mass Flow Rate", + Constant::Units::kg_s, fanExhaust->unbalancedOutletMassFlowRate, - OutputProcessor::TimeStepType::System, - OutputProcessor::StoreType::Average, + OutputProcessor::TimeStepType::System, + OutputProcessor::StoreType::Average, fanExhaust->Name); - SetupOutputVariable(state, - "Fan Balanced Air Mass Flow Rate", - Constant::Units::kg_s, + SetupOutputVariable(state, + "Fan Balanced Air Mass Flow Rate", + Constant::Units::kg_s, fanExhaust->balancedOutletMassFlowRate, - OutputProcessor::TimeStepType::System, - OutputProcessor::StoreType::Average, + OutputProcessor::TimeStepType::System, + OutputProcessor::StoreType::Average, fanExhaust->Name); - } + } } if (fan->type == HVAC::FanType::OnOff) { @@ -1161,12 +1161,12 @@ void GetFanInput(EnergyPlusData &state) if (fanSystem->speedControl != SpeedControl::Discrete) continue; if (fanSystem->numSpeeds == 1) { - SetupOutputVariable(state, - "Fan Runtime Fraction", - Constant::Units::None, + SetupOutputVariable(state, + "Fan Runtime Fraction", + Constant::Units::None, fanSystem->runtimeFracAtSpeed[0], - OutputProcessor::TimeStepType::System, - OutputProcessor::StoreType::Average, + OutputProcessor::TimeStepType::System, + OutputProcessor::StoreType::Average, fanSystem->Name); } else { for (int speedLoop = 0; speedLoop < fanSystem->numSpeeds; ++speedLoop) { @@ -1177,7 +1177,7 @@ void GetFanInput(EnergyPlusData &state) OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, fan->Name); - } + } } } @@ -1458,7 +1458,7 @@ void FanComponent::set_size(EnergyPlusData &state) _plBeltEff = Curve::CurveValue(state, plBeltEffReg3CurveNum, _torqueRatio); //[-] } else { _plBeltEff = 1.0; // Direct drive or no curve specified - use constant efficiency - } + } beltEff = beltMaxEff * _plBeltEff; //[-] beltEff = max(beltEff, 0.01); // Minimum efficiency is 1% to avoid numerical errors beltInputPower = shaftPower / beltEff; //[W] @@ -1497,26 +1497,26 @@ void FanComponent::set_size(EnergyPlusData &state) vfdEff = Curve::CurveValue(state, vfdEffCurveNum, _vfdSpeedRatio); } else if ((vfdEffType == VFDEffType::Power) && (vfdEffCurveNum != 0)) { if (vfdMaxOutPower == DataSizing::AutoSize) { - // WRITE(*,*) 'Autosizing fan VFD' + // WRITE(*,*) 'Autosizing fan VFD' vfdMaxOutPower = motorInputPower; - } - // Adjust max VFD output power using VFD sizing factor + } + // Adjust max VFD output power using VFD sizing factor vfdMaxOutPower *= vfdSizingFactor; //[W] - // Check for undersized VFD and report design size with warning + // Check for undersized VFD and report design size with warning if (motorInputPower > (vfdMaxOutPower + 1.e-5)) { ShowWarningError( state, format("VFD for {}: {} is undersized at design conditions -- check VFD inputs", HVAC::fanTypeNames[(int)type], Name)); ShowContinueError(state, format("...Design VFD output power (without oversizing) [W]: {:.2R}", motorInputPower)); - } + } Real64 _vfdOutPowerRatio = motorInputPower / vfdMaxOutPower; // Ratio of VFD output power to max VFD output power [-] vfdEff = Curve::CurveValue(state, vfdEffCurveNum, _vfdOutPowerRatio); - } else { - // No curve specified - use constant efficiency + } else { + // No curve specified - use constant efficiency vfdMaxOutPower = 0.0; vfdEff = 0.97; - } + } vfdEff = max(vfdEff, 0.01); // Minimum efficiency is 1% to avoid numerical errors @@ -1571,8 +1571,8 @@ void FanComponent::set_size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAutosized, Name, - maxAirFlowRateIsAutosizable ? "Yes" : "No"); // autosizable vs. autosized equivalent? - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motEff); + maxAirFlowRateIsAutosized ? "Yes" : "No"); // autosizable vs. autosized equivalent? + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motorEff); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, 0.0); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, "n/a"); OutputReportPredefined::PreDefTableEntry(state, @@ -2074,24 +2074,24 @@ void FanComponent::simulateZoneExhaust(EnergyPlusData &state) !state.dataHVACGlobal->TurnFansOff && _massFlow > 0.0) { // available if (minTempLimitSchedNum > 0) { _fanIsRunning = (_Tin >= ScheduleManager::GetCurrentScheduleValue(state, minTempLimitSchedNum)); - } else { - _fanIsRunning = true; - } } else { - _fanIsRunning = false; + _fanIsRunning = true; } + } else { + _fanIsRunning = false; + } } else if (availManagerMode == AvailManagerMode::Decoupled) { if (ScheduleManager::GetCurrentScheduleValue(state, availSchedNum) > 0.0 && _massFlow > 0.0) { if (minTempLimitSchedNum > 0) { _fanIsRunning = (_Tin >= ScheduleManager::GetCurrentScheduleValue(state, minTempLimitSchedNum)); - } else { - _fanIsRunning = true; - } } else { - _fanIsRunning = false; + _fanIsRunning = true; } + } else { + _fanIsRunning = false; } + } if (_fanIsRunning) { // Fan is operating @@ -2234,7 +2234,7 @@ void FanComponent::simulateComponentModel(EnergyPlusData &state) _beltPLEff = Curve::CurveValue(state, plBeltEffReg3CurveNum, _torqueRatio); //[-] } else { _beltPLEff = 1.0; // Direct drive or no curve specified - use constant efficiency - } + } beltEff = beltMaxEff * _beltPLEff; //[-] beltEff = max(beltEff, 0.01); // Minimum efficiency is 1% to avoid numerical errors @@ -2262,10 +2262,10 @@ void FanComponent::simulateComponentModel(EnergyPlusData &state) _vfdOutPowerRatio = motorInputPower / vfdMaxOutPower; //[-] vfdEff = Curve::CurveValue(state, vfdEffCurveNum, _vfdOutPowerRatio); //[-] } else { - // No curve specified - use constant efficiency + // No curve specified - use constant efficiency vfdMaxOutPower = 0.0; vfdEff = 0.97; - } + } vfdEff = max(vfdEff, 0.01); // Minimum efficiency is 1% to avoid numerical errors // Calculate VFD input power using motor input power and VFD efficiency @@ -2487,7 +2487,7 @@ Real64 FanComponent::getDesignHeatGain(EnergyPlusData &state, if (!state.dataGlobal->SysSizingCalc && sizingFlag) { set_size(state); sizingFlag = false; - } + } return shaftPower + (motorInputPower - shaftPower) * motorInAirFrac; } } // FanComponent::getDesignHeatGain() @@ -2666,7 +2666,11 @@ void FanSystem::set_size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanPurpose, Name, "N/A"); // m_fanType); // purpose? not the same OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAutosized, Name, maxAirFlowRateIsAutosized ? "Yes" : "No"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motorEff); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, motorInAirFrac); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, 1 - motorInAirFrac); + if (heatLossDest == HeatLossDest::Zone) { + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, state.dataHeatBal->Zone(zoneNum).Name); + } OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, @@ -2750,12 +2754,12 @@ void FanSystem::calcSimpleSystemFan( if (present(_flowFraction)) { _localFlowFrac = _flowFraction; _localAirMassFlow[0] = _localFlowFrac * maxAirMassFlowRate; - } else { + } else { if (maxAirMassFlowRate > 0.0) { // protect div by 0 _localFlowFrac = inletAirMassFlowRate / maxAirMassFlowRate; } else { _localFlowFrac = 1.0; - } + } _localAirMassFlow[0] = inletAirMassFlowRate; } if (present(_flowRatio1) && present(_flowRatio2) && present(_runTimeFrac1) && present(_runTimeFrac2)) { @@ -2786,7 +2790,7 @@ void FanSystem::calcSimpleSystemFan( _localFaultMaxAirMassFlow = maxAirMassFlowRate - _designFlowRateDec * rhoAirStdInit; _localFaultPressureRise = _pressFrac * deltaPress; - } + } } for (int mode = 0; mode < _numModes; ++mode) { @@ -2799,13 +2803,13 @@ void FanSystem::calcSimpleSystemFan( if (_faultActive) { _localAirMassFlow[mode] = min(_localAirMassFlow[mode], _localFaultMaxAirMassFlow); _localPressureRise[mode] = _localFaultPressureRise; - } + } _localFlowFrac = _localAirMassFlow[0] / maxAirMassFlowRate; _localFlowFrac = min(1.0, _localFlowFrac); if (_localRuntimeFrac[mode] > 0.0) { _localFlowRatio[mode] = _localAirMassFlow[mode] / (maxAirMassFlowRate * _localRuntimeFrac[mode]); - } + } _localFlowRatio[mode] = min(1.0, _localFlowRatio[mode]); } @@ -2834,7 +2838,7 @@ void FanSystem::calcSimpleSystemFan( // if (state.dataHVACGlobal->OnOffFanPartLoadFraction <= 0.0) { state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; - } + } if (state.dataHVACGlobal->OnOffFanPartLoadFraction < 0.7) { state.dataHVACGlobal->OnOffFanPartLoadFraction = 0.7; // a warning message is already issued from the DX coils or gas heating coil } @@ -2923,8 +2927,8 @@ void FanSystem::calcSimpleSystemFan( if ((flowFracAtSpeed[loop] <= _locRuntimeFrac) && (_locRuntimeFrac <= flowFracAtSpeed[loop + 1])) { _lowSideSpeed = loop; _hiSideSpeed = loop + 1; - break; - } + break; + } } _locLowSpeedRuntimeFrac = (flowFracAtSpeed[_hiSideSpeed] - _locRuntimeFrac) / (flowFracAtSpeed[_hiSideSpeed] - flowFracAtSpeed[_lowSideSpeed]); @@ -2959,7 +2963,7 @@ void FanSystem::calcSimpleSystemFan( } else { _locFlowRatio = _localFlowFrac; _locRuntimeFrac = 1.0; - } + } Real64 _localFlowFracForPower = max(minPowerFlowFrac, _locFlowRatio); Real64 _localPowerFrac = (state.dataHVACGlobal->NightVentOn) ? 1.0 : // not sure why, but legacy fan had this for night ventilation @@ -3084,9 +3088,9 @@ void FanSystem::update(EnergyPlusData &state) // does not change state of object state.dataAirLoop->AirLoopAFNInfo(airLoopNum).AFNLoopOnOffFanRTF = outletAirMassFlowRate / massFlowAtSpeed[0]; } else { state.dataAirLoop->AirLoopAFNInfo(airLoopNum).AFNLoopOnOffFanRTF = 1.0; + } } } - } } // FanSystem::update() void FanSystem::report(EnergyPlusData &state) @@ -3112,7 +3116,7 @@ Real64 FanSystem::getDesignHeatGain(EnergyPlusData &state, Real64 const _volFlow { if (sizingFlag) { set_size(state); - } + } Real64 _fanPowerTot = (_volFlow * deltaPress) / totalEff; return motorEff * _fanPowerTot + (_fanPowerTot - motorEff * _fanPowerTot) * motorInAirFrac; diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 2a432cf2ae1..aab66e1273c 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -2160,7 +2160,7 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HCoilNamesUC[(int)this->HCoilType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNames[(int)this->fanType]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, HVAC::fanTypeNames[(int)this->fanType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName); } diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 1f5057c800b..908e89fc059 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -6493,7 +6493,7 @@ void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->ReheatComp); OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a"); if ((int)this->fanType >= 0) { - OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, DataHVACGlobals::fanTypeNames[(int)this->fanType]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, HVAC::fanTypeNames[(int)this->fanType]); } else { OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a"); } diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 018e08b5beb..c8ce00c075b 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4861,14 +4861,14 @@ void reportAirLoopToplogy(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirSupplyPCompType, format("{}", rowCounter), thisSupplyPath.ComponentType(compNum)); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirSupplyPCompName, format("{}", rowCounter), thisSupplyPath.ComponentName(compNum)); ++rowCounter; } - if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Cooling || thisBranch.DuctType == DataHVACGlobals::AirDuctType::Main) { + if (thisBranch.DuctType == HVAC::AirDuctType::Cooling || thisBranch.DuctType == HVAC::AirDuctType::Main) { for (int zoneNum : thisAtoZInfo.CoolCtrlZoneNums) { auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); @@ -4888,7 +4888,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), - DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); auto &aduIndex = zel.EquipIndex(thisCoolADU.AirDistUnitIndex); @@ -4922,7 +4922,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) ++rowCounter; } } - } else if (thisBranch.DuctType == DataHVACGlobals::AirDuctType::Heating) { + } else if (thisBranch.DuctType == HVAC::AirDuctType::Heating) { for (int zoneNum : thisAtoZInfo.HeatCtrlZoneNums) { auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(zoneNum); auto &zel = state.dataZoneEquip->ZoneEquipList(zoneNum); @@ -4942,7 +4942,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), - DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); auto &aduIndex = zel.EquipIndex(thisHeatADU.AirDistUnitIndex); @@ -4979,7 +4979,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); ++rowCounter; } } @@ -4991,7 +4991,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) auto &thisBranch = pas.Branch(pas.InletBranchNum[0]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)thisBranch.DuctType]); + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); } OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirReturnPCompType, format("{}", rowCounter), thisReturnPath.ComponentType(compNum)); @@ -5006,7 +5006,7 @@ void reportAirLoopToplogy(EnergyPlusData &state) void fillAirloopToplogyComponentRow(EnergyPlusData &state, const std::string_view &loopName, const std::string_view &branchName, - const DataHVACGlobals::AirDuctType ductType, + const HVAC::AirDuctType ductType, const std::string_view &compType, const std::string_view &compName, int &rowCounter) @@ -5019,7 +5019,7 @@ void fillAirloopToplogyComponentRow(EnergyPlusData &state, OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), loopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirBranchName, format("{}", rowCounter), branchName); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyBranchType, format("{}", rowCounter), DataHVACGlobals::airDuctTypeNames[(int)ductType]); + state, orp->pdchTopAirSupplyBranchType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)ductType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompType, format("{}", rowCounter), compType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompName, format("{}", rowCounter), compName); ++rowCounter; diff --git a/src/EnergyPlus/SystemReports.hh b/src/EnergyPlus/SystemReports.hh index 2c9aabee046..6822e833da2 100644 --- a/src/EnergyPlus/SystemReports.hh +++ b/src/EnergyPlus/SystemReports.hh @@ -337,7 +337,7 @@ namespace SystemReports { void fillAirloopToplogyComponentRow(EnergyPlusData &state, const std::string_view &loopName, const std::string_view &branchName, - const DataHVACGlobals::AirDuctType ductType, + const HVAC::AirDuctType ductType, const std::string_view &compType, const std::string_view &compName, int &rowCounter); diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.cc b/src/EnergyPlus/ZoneTempPredictorCorrector.cc index 1f5480ddeb4..feb9e96e467 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.cc +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.cc @@ -7067,26 +7067,26 @@ void FillPredefinedTableOnThermostatSchedules(EnergyPlusData &state) PreDefTableEntry(state, orp->pdchStatName, tcz.ZoneName, tcz.Name); PreDefTableEntry(state, orp->pdchStatCtrlTypeSchd, tcz.ZoneName, tcz.ControlTypeSchedName); for (int ctInx = 1; ctInx <= tcz.NumControlTypes; ++ctInx) { - PreDefTableEntry(state, orp->pdchStatSchdType1, tcz.ZoneName, DataHVACGlobals::thermostatTypeNames[(int)tcz.ControlTypeEnum(ctInx)]); + PreDefTableEntry(state, orp->pdchStatSchdType1, tcz.ZoneName, HVAC::thermostatTypeNames[(int)tcz.ControlTypeEnum(ctInx)]); PreDefTableEntry(state, orp->pdchStatSchdTypeName1, tcz.ZoneName, tcz.ControlTypeName(1)); switch (tcz.ControlTypeEnum(ctInx)) { - case DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand: + case HVAC::ThermostatType::DualSetPointWithDeadBand: PreDefTableEntry( state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandHeat)); PreDefTableEntry( state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_DualSetPointWDeadBandCool)); break; - case DataHVACGlobals::ThermostatType::SingleHeatCool: + case HVAC::ThermostatType::SingleHeatCool: PreDefTableEntry( state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); PreDefTableEntry( state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatCoolSetPoint)); break; - case DataHVACGlobals::ThermostatType::SingleCooling: + case HVAC::ThermostatType::SingleCooling: PreDefTableEntry( state, orp->pdchStatSchdHeatName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleCoolSetPoint)); break; - case DataHVACGlobals::ThermostatType::SingleHeating: + case HVAC::ThermostatType::SingleHeating: PreDefTableEntry( state, orp->pdchStatSchdCoolName, tcz.ZoneName, ScheduleManager::GetScheduleName(state, tcz.SchIndx_SingleHeatSetPoint)); break; diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc index 6d2e391f139..464bc1d1e64 100644 --- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc +++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc @@ -1999,7 +1999,7 @@ TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) piu(1).MaxPriAirVolFlow = 0.30; piu(1).MaxSecAirVolFlow = 0.25; piu(1).HCoilType = PoweredInductionUnits::HtgCoilType::Electric; - piu(1).fanType = DataHVACGlobals::FanType::Constant; + piu(1).fanType = HVAC::FanType::Constant; piu(1).FanName = "FanA"; piu(1).reportTerminalUnit(*state); diff --git a/tst/EnergyPlus/unit/SingleDuct.unit.cc b/tst/EnergyPlus/unit/SingleDuct.unit.cc index b983fb6eba4..f63cc1b191b 100644 --- a/tst/EnergyPlus/unit/SingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/SingleDuct.unit.cc @@ -3053,7 +3053,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) sdat(1).MaxAirVolFlowRateDuringReheat = 0.25; sdat(1).OARequirementsPtr = 0; sdat(1).ReheatComp = "watercoil"; - sdat(1).fanType = DataHVACGlobals::FanType::VAV; + sdat(1).fanType = HVAC::FanType::VAV; sdat(1).FanName = "FanA"; sdat(1).reportTerminalUnit(*state); @@ -3092,7 +3092,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit) sdat(2).MaxAirVolFlowRateDuringReheat = 0.26; sdat(2).OARequirementsPtr = 1; sdat(2).ReheatComp = "furncoil"; - sdat(2).fanType = DataHVACGlobals::FanType::OnOff; + sdat(2).fanType = HVAC::FanType::OnOff; sdat(2).FanName = "FanB"; auto &oa = state->dataSize->OARequirements; diff --git a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc index e7875195709..3ce5a6ecdd1 100644 --- a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc +++ b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc @@ -1718,7 +1718,7 @@ TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) dzc.TempControlledZone(1).NumControlTypes = 1; dzc.TempControlledZone(1).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); dzc.TempControlledZone(1).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); - dzc.TempControlledZone(1).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleHeating; + dzc.TempControlledZone(1).ControlTypeEnum(1) = HVAC::ThermostatType::SingleHeating; dzc.TempControlledZone(1).ControlTypeName(1) = "control A"; dzc.TempControlledZone(1).SchIndx_SingleHeatSetPoint = 1; state->dataScheduleMgr->Schedule(1).Name = "schA"; @@ -1729,7 +1729,7 @@ TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) dzc.TempControlledZone(2).NumControlTypes = 1; dzc.TempControlledZone(2).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); dzc.TempControlledZone(2).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); - dzc.TempControlledZone(2).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleCooling; + dzc.TempControlledZone(2).ControlTypeEnum(1) = HVAC::ThermostatType::SingleCooling; dzc.TempControlledZone(2).ControlTypeName(1) = "control B"; dzc.TempControlledZone(2).SchIndx_SingleCoolSetPoint = 2; state->dataScheduleMgr->Schedule(2).Name = "schB"; @@ -1740,7 +1740,7 @@ TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) dzc.TempControlledZone(3).NumControlTypes = 1; dzc.TempControlledZone(3).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); dzc.TempControlledZone(3).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); - dzc.TempControlledZone(3).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::SingleHeatCool; + dzc.TempControlledZone(3).ControlTypeEnum(1) = HVAC::ThermostatType::SingleHeatCool; dzc.TempControlledZone(3).ControlTypeName(1) = "control C"; dzc.TempControlledZone(3).SchIndx_SingleHeatCoolSetPoint = 3; state->dataScheduleMgr->Schedule(3).Name = "schC"; @@ -1751,7 +1751,7 @@ TEST_F(EnergyPlusFixture, FillPredefinedTableOnThermostatSchedules_Test) dzc.TempControlledZone(4).NumControlTypes = 1; dzc.TempControlledZone(4).ControlTypeEnum.allocate(dzc.TempControlledZone(1).NumControlTypes); dzc.TempControlledZone(4).ControlTypeName.allocate(dzc.TempControlledZone(1).NumControlTypes); - dzc.TempControlledZone(4).ControlTypeEnum(1) = DataHVACGlobals::ThermostatType::DualSetPointWithDeadBand; + dzc.TempControlledZone(4).ControlTypeEnum(1) = HVAC::ThermostatType::DualSetPointWithDeadBand; dzc.TempControlledZone(4).ControlTypeName(1) = "control D"; dzc.TempControlledZone(4).SchIndx_DualSetPointWDeadBandHeat = 4; dzc.TempControlledZone(4).SchIndx_DualSetPointWDeadBandCool = 5; From 4b49ea8330f4d3e25f1f1b14cafbbff0617db5e9 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 7 May 2024 16:00:42 -0500 Subject: [PATCH 057/115] Add missing AirTerminal:UserDefined inits --- src/EnergyPlus/UserDefinedComponents.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/EnergyPlus/UserDefinedComponents.cc b/src/EnergyPlus/UserDefinedComponents.cc index edce549a41f..af8e1754914 100644 --- a/src/EnergyPlus/UserDefinedComponents.cc +++ b/src/EnergyPlus/UserDefinedComponents.cc @@ -2109,6 +2109,10 @@ namespace UserDefinedComponents { state.dataUserDefinedComponents->UserAirTerminal(CompLoop).AirLoop.InletNodeNum; state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = state.dataUserDefinedComponents->UserAirTerminal(CompLoop).AirLoop.OutletNodeNum; + state.dataDefineEquipment->AirDistUnit(state.dataUserDefinedComponents->UserAirTerminal(CompLoop).ADUNum) + .TermUnitSizingNum = state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex; + state.dataDefineEquipment->AirDistUnit(state.dataUserDefinedComponents->UserAirTerminal(CompLoop).ADUNum).ZoneEqNum = + CtrlZone; } state.dataUserDefinedComponents->UserAirTerminal(CompLoop).ActualCtrlZoneNum = CtrlZone; From 532b8f42deac828642efd01bcc11da3371615f6f Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 7 May 2024 18:04:52 -0500 Subject: [PATCH 058/115] format --- src/EnergyPlus/DataAirLoop.hh | 6 +-- src/EnergyPlus/OutdoorAirUnit.hh | 62 ++++++++++++++-------------- src/EnergyPlus/SimAirServingZones.cc | 20 ++++----- src/EnergyPlus/SystemReports.cc | 15 +++---- 4 files changed, 49 insertions(+), 54 deletions(-) diff --git a/src/EnergyPlus/DataAirLoop.hh b/src/EnergyPlus/DataAirLoop.hh index c93290764df..cdd74c92e50 100644 --- a/src/EnergyPlus/DataAirLoop.hh +++ b/src/EnergyPlus/DataAirLoop.hh @@ -87,9 +87,9 @@ namespace DataAirLoop { Array1D_int TermUnitCoolSizingIndex; // Air terminal sizing numbers for zones cooled by this air loop Array1D_int TermUnitHeatSizingIndex; // Air terminal sizing numbers for zones heated by this air loop Array1D SupplyDuctType; // 1=main, 2=cooling, 3=heating, 4=other - Array1D_int SupplyDuctBranchNum; // Supply duct branch number - Array1D_int SupplyAirPathNum; // Supply air path indexes - Array1D_int ReturnAirPathNum; // Return air path indexes + Array1D_int SupplyDuctBranchNum; // Supply duct branch number + Array1D_int SupplyAirPathNum; // Supply air path indexes + Array1D_int ReturnAirPathNum; // Return air path indexes }; struct AirLoopOutsideAirConnectData diff --git a/src/EnergyPlus/OutdoorAirUnit.hh b/src/EnergyPlus/OutdoorAirUnit.hh index 3a1b378f23c..8d42f2ed2d6 100644 --- a/src/EnergyPlus/OutdoorAirUnit.hh +++ b/src/EnergyPlus/OutdoorAirUnit.hh @@ -180,40 +180,40 @@ namespace OutdoorAirUnit { int ZoneNodeNum; // index of zone air node in node structure std::string UnitControlType; // Control type for the system // (Neutral and setpoint temperatrue) - OAUnitCtrlType controlType; // Unit Control type indicator - int AirInletNode; // inlet air node number - int AirOutletNode; // outlet air node number - std::string SFanName; // name of supply fan - int SFan_Index; // index in fan structure + OAUnitCtrlType controlType; // Unit Control type indicator + int AirInletNode; // inlet air node number + int AirOutletNode; // outlet air node number + std::string SFanName; // name of supply fan + int SFan_Index; // index in fan structure HVAC::FanType supFanType; // type of fan in cFanTypes - int SFanAvailSchedPtr; // supply fan availability sched from fan object + int SFanAvailSchedPtr; // supply fan availability sched from fan object HVAC::FanPlace supFanPlace; // fan placement; blow through and draw through - Real64 FanCorTemp; // correction temperature - bool FanEffect; // .TRUE. if unit has a fan type of draw through - int SFanOutletNode; // supply fan outlet node number - std::string ExtFanName; // name of exhaust fan - int ExtFan_Index; // index in fan structure + Real64 FanCorTemp; // correction temperature + bool FanEffect; // .TRUE. if unit has a fan type of draw through + int SFanOutletNode; // supply fan outlet node number + std::string ExtFanName; // name of exhaust fan + int ExtFan_Index; // index in fan structure HVAC::FanType extFanType; // type of fan in cFanTypes - int ExtFanAvailSchedPtr; // exhaust fan availability sched from fan object - bool ExtFan; // true if there is an exhaust fan - std::string OutAirSchedName; // schedule of fraction for outside air (all controls) - int OutAirSchedPtr; // index to schedule - int OutsideAirNode; // outside air node number - Real64 OutAirVolFlow; // m3/s - Real64 OutAirMassFlow; // kg/s - Real64 ExtAirVolFlow; // m3/s - Real64 ExtAirMassFlow; // kg/s - std::string ExtAirSchedName; // schedule of fraction for exhaust air - int ExtOutAirSchedPtr; // index to schedule - Real64 SMaxAirMassFlow; // kg/s - Real64 EMaxAirMassFlow; // kg/s - Real64 SFanMaxAirVolFlow; // m3/s - Real64 EFanMaxAirVolFlow; // m3/s - std::string HiCtrlTempSched; // Schedule name for the High Control Air temperature - int HiCtrlTempSchedPtr; // Schedule index for the High Control Air temperature - std::string LoCtrlTempSched; // Schedule name for the Low Control Air temperature - int LoCtrlTempSchedPtr; // Schedule index for the Low Control Air temperature - Operation OperatingMode; // operating condition( NeutralMode, HeatingMode, CoolingMode) + int ExtFanAvailSchedPtr; // exhaust fan availability sched from fan object + bool ExtFan; // true if there is an exhaust fan + std::string OutAirSchedName; // schedule of fraction for outside air (all controls) + int OutAirSchedPtr; // index to schedule + int OutsideAirNode; // outside air node number + Real64 OutAirVolFlow; // m3/s + Real64 OutAirMassFlow; // kg/s + Real64 ExtAirVolFlow; // m3/s + Real64 ExtAirMassFlow; // kg/s + std::string ExtAirSchedName; // schedule of fraction for exhaust air + int ExtOutAirSchedPtr; // index to schedule + Real64 SMaxAirMassFlow; // kg/s + Real64 EMaxAirMassFlow; // kg/s + Real64 SFanMaxAirVolFlow; // m3/s + Real64 EFanMaxAirVolFlow; // m3/s + std::string HiCtrlTempSched; // Schedule name for the High Control Air temperature + int HiCtrlTempSchedPtr; // Schedule index for the High Control Air temperature + std::string LoCtrlTempSched; // Schedule name for the Low Control Air temperature + int LoCtrlTempSchedPtr; // Schedule index for the Low Control Air temperature + Operation OperatingMode; // operating condition( NeutralMode, HeatingMode, CoolingMode) int ControlCompTypeNum; int CompErrIndex; Real64 AirMassFlow; // kg/s diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc index 5052255ec95..51934e8c4fe 100644 --- a/src/EnergyPlus/SimAirServingZones.cc +++ b/src/EnergyPlus/SimAirServingZones.cc @@ -433,7 +433,7 @@ void GetAirPathData(EnergyPlusData &state) primaryAirSystems.NumOAHeatCoils = 0; primaryAirSystems.NumOACoolCoils = 0; AirLoopControlInfo(AirSysNum).FanOpMode = HVAC::ContFanCycCoil; // initialize to constant fan mode for all air loops - state.dataAirLoop->AirLoopFlow(AirSysNum).FanPLR = 1.0; // initialize to 1 for all air loops + state.dataAirLoop->AirLoopFlow(AirSysNum).FanPLR = 1.0; // initialize to 1 for all air loops CurrentModuleObject = "AirLoopHVAC"; @@ -1182,7 +1182,7 @@ void GetAirPathData(EnergyPlusData &state) comp.CompIndex = Fans::GetFanIndex(state, comp.Name); // TODO: get rid of this if (comp.CompIndex == 0) { ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf)); - } + } } state.dataFans->fans(comp.CompIndex)->airPathFlag = true; @@ -1937,7 +1937,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE if (compType == CompType::OAMixer_Num) { FoundOASys = true; } else if (compType == CompType::WaterCoil_Cooling || compType == CompType::WaterCoil_DetailedCool || - compType == CompType::WaterCoil_CoolingHXAsst || compType == CompType::DXSystem) { + compType == CompType::WaterCoil_CoolingHXAsst || compType == CompType::DXSystem) { FoundCentralCoolCoil = true; } else if (compType == CompType::Fan_Simple_CV || compType == CompType::Fan_Simple_VAV || compType == CompType::Fan_ComponentModel || compType == CompType::Fan_System_Object) { @@ -1947,16 +1947,16 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE SupFanIndex = comp.CompIndex = Fans::GetFanIndex(state, comp.Name); supFanType = state.dataFans->fans(SupFanIndex)->type; goto EndOfAirLoop; - } else { + } else { // Grab CompIndex but don't set airLoop.supFanType or retFanType? comp.CompIndex = Fans::GetFanIndex(state, comp.Name); - } - } else { + } + } else { RetFanIndex = comp.CompIndex = Fans::GetFanIndex(state, comp.Name); retFanType = state.dataFans->fans(RetFanIndex)->type; // no goto here? - } - } else { + } + } else { SupFanIndex = comp.CompIndex = Fans::GetFanIndex(state, comp.Name); supFanType = state.dataFans->fans(SupFanIndex)->type; goto EndOfAirLoop; @@ -1977,7 +1977,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE thisPrimaryAirSys.retFanType = retFanType; thisPrimaryAirSys.retFanNum = RetFanIndex; - } + } // Check whether there are Central Heating Coils in the Primary Air System for (int AirLoopNum = 1; AirLoopNum <= numPrimaryAirSys; ++AirLoopNum) { auto &thisPrimaryAirSys = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum); @@ -3464,7 +3464,7 @@ void SimAirLoopComponent(EnergyPlusData &state, state.dataFans->fans(CompIndex)->simulate(state, FirstHVACIteration); } break; - case CompType::Fan_System_Object: { // "Fan:SystemModel" new for V8.6 + case CompType::Fan_System_Object: { // "Fan:SystemModel" new for V8.6 // if the fan is here, it can't (yet) really be cycling fan operation, set this ugly global in the event that there are dx coils // involved but the fan should really run like constant volume and not cycle with compressor state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index c8ce00c075b..81a1c6903ed 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4885,10 +4885,8 @@ void reportAirLoopToplogy(EnergyPlusData &state) state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); - OutputReportPredefined::PreDefTableEntry(state, - orp->pdchTopAirSupplyDuctType, - format("{}", rowCounter), - HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); auto &aduIndex = zel.EquipIndex(thisCoolADU.AirDistUnitIndex); @@ -4939,10 +4937,8 @@ void reportAirLoopToplogy(EnergyPlusData &state) state, orp->pdchTopAirDemandName, format("{}", rowCounter), thisAtoZInfo.AirLoopName); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirSupplyBranchName, format("{}", rowCounter), thisBranch.Name); - OutputReportPredefined::PreDefTableEntry(state, - orp->pdchTopAirSupplyDuctType, - format("{}", rowCounter), - HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); + OutputReportPredefined::PreDefTableEntry( + state, orp->pdchTopAirSupplyDuctType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)thisBranch.DuctType]); OutputReportPredefined::PreDefTableEntry( state, orp->pdchTopAirZoneName, format("{}", rowCounter), thisZoneEquipConfig.ZoneName); auto &aduIndex = zel.EquipIndex(thisHeatADU.AirDistUnitIndex); @@ -5018,8 +5014,7 @@ void fillAirloopToplogyComponentRow(EnergyPlusData &state, // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirLoopName, format("{}", rowCounter), loopName); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirBranchName, format("{}", rowCounter), branchName); - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirSupplyBranchType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)ductType]); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSupplyBranchType, format("{}", rowCounter), HVAC::airDuctTypeNames[(int)ductType]); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompType, format("{}", rowCounter), compType); OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirCompName, format("{}", rowCounter), compName); ++rowCounter; From 2e6db02d419699bf24975ec46d181a240a87d857 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Mon, 13 May 2024 16:42:16 -0500 Subject: [PATCH 059/115] Revert air loop supply side topology to subsub format --- src/EnergyPlus/OutputReportPredefined.cc | 8 +++--- src/EnergyPlus/OutputReportPredefined.hh | 9 +++--- src/EnergyPlus/SystemReports.cc | 35 ++++++++++-------------- 3 files changed, 24 insertions(+), 28 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 6d6302f0313..0d5e4b754e2 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -943,11 +943,11 @@ namespace OutputReportPredefined { s->pdchTopAirSupplyBranchType = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Type"); s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); + s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); + s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); + s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); + s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); - s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); - s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); - s->pdchTopAirParentCompType2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type 2"); - s->pdchTopAirParentCompName2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name 2"); s->pdstTopAirDemand = newPreDefSubTable(state, s->pdrTopology, "Air Loop Demand Side Component Arrangement"); s->pdchTopAirDemandName = newPreDefColumn(state, s->pdstTopAirDemand, "Airloop Name"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index c5048120829..0553d137a89 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -906,11 +906,12 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchTopAirSupplyBranchType = 0; int pdchTopAirCompType = 0; int pdchTopAirCompName = 0; + int pdchTopAirSubCompType = 0; + int pdchTopAirSubCompName = 0; + int pdchTopAirSubSubCompType = 0; + int pdchTopAirSubSubCompName = 0; + int pdchTopAirDownSplitMixName = 0; int pdchTopAirMixName = 0; - int pdchTopAirParentCompType = 0; - int pdchTopAirParentCompName = 0; - int pdchTopAirParentCompType2 = 0; - int pdchTopAirParentCompName2 = 0; int pdstTopAirDemand = 0; int pdchTopAirDemandName = 0; diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index 81a1c6903ed..3fdca19f63f 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -4774,11 +4774,11 @@ void reportAirLoopToplogy(EnergyPlusData &state) // s->pdchTopAirSupplyBranchType = newPreDefColumn(state, s->pdstTopAirLoop, "Supply Branch Type"); // s->pdchTopAirCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Component Type"); // s->pdchTopAirCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Component Name"); + // s->pdchTopAirSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Type"); + // s->pdchTopAirSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Component Name"); + // s->pdchTopAirSubSubCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Type"); + // s->pdchTopAirSubSubCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Sub-Sub-Component Name"); // s->pdchTopAirMixName = newPreDefColumn(state, s->pdstTopAirLoop, "Mixer Name"); - // s->pdchTopAirParentCompType = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type"); - // s->pdchTopAirParentCompName = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name"); - // s->pdchTopAirParentCompType2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Type 2"); - // s->pdchTopAirParentCompName2 = newPreDefColumn(state, s->pdstTopAirLoop, "Parent Component Name 2"); auto &orp = state.dataOutRptPredefined; int rowCounter = 1; @@ -4798,30 +4798,25 @@ void reportAirLoopToplogy(EnergyPlusData &state) } for (int CompNum = 1; CompNum <= pasBranch.TotalComponents; ++CompNum) { auto &pasBranchComp = pasBranch.Comp(CompNum); - if (pasBranchComp.NumSubComps == 0) { - fillAirloopToplogyComponentRow( - state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); - } + fillAirloopToplogyComponentRow( + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); for (int SubCompNum = 1; SubCompNum <= pasBranchComp.NumSubComps; ++SubCompNum) { auto &pasBranchSubComp = pasBranchComp.SubComp(SubCompNum); - if (pasBranchSubComp.NumSubSubComps == 0) { - OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchComp.TypeOf); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchComp.Name); - fillAirloopToplogyComponentRow( - state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchSubComp.TypeOf, pasBranchSubComp.Name, rowCounter); - } + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); + fillAirloopToplogyComponentRow( + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); for (int SubSubCompNum = 1; SubSubCompNum <= pasBranchSubComp.NumSubSubComps; ++SubSubCompNum) { auto &pasBranchSubSubComp = pasBranchSubComp.SubSubComp(SubSubCompNum); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompType, format("{}", rowCounter), pasBranchComp.TypeOf); - OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirParentCompName, format("{}", rowCounter), pasBranchComp.Name); + state, orp->pdchTopAirSubCompType, format("{}", rowCounter), pasBranchSubComp.TypeOf); + OutputReportPredefined::PreDefTableEntry(state, orp->pdchTopAirSubCompName, format("{}", rowCounter), pasBranchSubComp.Name); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompType2, format("{}", rowCounter), pasBranchSubComp.TypeOf); + state, orp->pdchTopAirSubSubCompType, format("{}", rowCounter), pasBranchSubSubComp.TypeOf); OutputReportPredefined::PreDefTableEntry( - state, orp->pdchTopAirParentCompName2, format("{}", rowCounter), pasBranchSubComp.Name); + state, orp->pdchTopAirSubSubCompName, format("{}", rowCounter), pasBranchSubSubComp.Name); fillAirloopToplogyComponentRow( - state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchSubSubComp.TypeOf, pasBranchSubSubComp.Name, rowCounter); + state, pas.Name, pasBranch.Name, pasBranch.DuctType, pasBranchComp.TypeOf, pasBranchComp.Name, rowCounter); } } } From 90a7992f72b664212805b7ec63719783f6426e51 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 14 May 2024 08:46:20 -0500 Subject: [PATCH 060/115] Fan reporting cleanup --- src/EnergyPlus/Fans.cc | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/EnergyPlus/Fans.cc b/src/EnergyPlus/Fans.cc index c21b58750b4..cd24dd78c8f 100644 --- a/src/EnergyPlus/Fans.cc +++ b/src/EnergyPlus/Fans.cc @@ -1350,6 +1350,7 @@ void FanComponent::set_size(EnergyPlusData &state) state.dataSize->DataAutosizable = maxAirFlowRateIsAutosized; state.dataSize->DataEMSOverrideON = EMSMaxAirFlowRateOverrideOn; state.dataSize->DataEMSOverride = EMSMaxAirFlowRateValue; + airLoopNum = state.dataSize->CurSysNum; bool errorsFound = false; SystemAirFlowSizer sizerSystemAirFlow; @@ -1574,7 +1575,7 @@ void FanComponent::set_size(EnergyPlusData &state) maxAirFlowRateIsAutosized ? "Yes" : "No"); // autosizable vs. autosized equivalent? OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motorEff); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, 0.0); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, "n/a"); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, "N/A"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, @@ -2583,6 +2584,7 @@ void FanSystem::set_size(EnergyPlusData &state) state.dataSize->DataAutosizable = true; state.dataSize->DataEMSOverrideON = EMSMaxAirFlowRateOverrideOn; state.dataSize->DataEMSOverride = EMSMaxAirFlowRateValue; + airLoopNum = state.dataSize->CurSysNum; bool ErrorsFound = false; SystemAirFlowSizer sizerSystemAirFlow; @@ -2667,10 +2669,10 @@ void FanSystem::set_size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAutosized, Name, maxAirFlowRateIsAutosized ? "Yes" : "No"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motorEff); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, 1 - motorInAirFrac); - if (heatLossDest == HeatLossDest::Zone) { - OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, state.dataHeatBal->Zone(zoneNum).Name); - } + OutputReportPredefined::PreDefTableEntry(state, + state.dataOutRptPredefined->pdchFanMotorHeatZone, + Name, + heatLossDest == HeatLossDest::Zone ? state.dataHeatBal->Zone(zoneNum).Name : "N/A"); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, From 213ac6efe751efe0721bf7a803603b590e71e3b0 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 14 May 2024 09:20:39 -0500 Subject: [PATCH 061/115] Add isAFNFan flag --- src/EnergyPlus/Fans.cc | 12 +++++------- src/EnergyPlus/Fans.hh | 1 + 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/EnergyPlus/Fans.cc b/src/EnergyPlus/Fans.cc index cd24dd78c8f..4df69008478 100644 --- a/src/EnergyPlus/Fans.cc +++ b/src/EnergyPlus/Fans.cc @@ -2387,8 +2387,8 @@ void FanComponent::report(EnergyPlusData &state) totalEnergy = totalPower * state.dataHVACGlobal->TimeStepSysSec; deltaTemp = outletAirTemp - inletAirTemp; - if (type == HVAC::FanType::OnOff) { - if (airLoopNum > 0) { + if (isAFNFan && (airLoopNum > 0)) { + if (type == HVAC::FanType::OnOff) { state.dataAirLoop->AirLoopAFNInfo(airLoopNum).AFNLoopOnOffFanRTF = runtimeFrac; } } @@ -3078,12 +3078,10 @@ void FanSystem::update(EnergyPlusData &state) // does not change state of object state.dataLoopNodes->Node(outletNodeNum).GenContam = state.dataLoopNodes->Node(inletNodeNum).GenContam; } - if (speedControl == SpeedControl::Continuous) { - if (airLoopNum > 0) { + if (isAFNFan && (airLoopNum > 0)) { + if (speedControl == SpeedControl::Continuous) { state.dataAirLoop->AirLoopAFNInfo(airLoopNum).AFNLoopOnOffFanRTF = runtimeFracAtSpeed[0]; - } - } else { - if (airLoopNum > 0) { + } else { if (numSpeeds == 1) { state.dataAirLoop->AirLoopAFNInfo(airLoopNum).AFNLoopOnOffFanRTF = outletAirMassFlowRate / maxAirMassFlowRate; } else if (outletAirMassFlowRate <= massFlowAtSpeed[0]) { diff --git a/src/EnergyPlus/Fans.hh b/src/EnergyPlus/Fans.hh index fd2036f1676..1df9ca4712b 100644 --- a/src/EnergyPlus/Fans.hh +++ b/src/EnergyPlus/Fans.hh @@ -126,6 +126,7 @@ namespace Fans { int outletNodeNum = 0; int airLoopNum = 0; bool airPathFlag = false; // Yes, this fan is a part of airpath + bool isAFNFan = false; // Is fan part of and AirFlowNetwork distribution system Real64 maxAirFlowRate = 0.0; // Max Specified Volume Flow Rate of Fan [m3/sec] Real64 minAirFlowRate = 0.0; // Max Specified Volume Flow Rate of Fan [m3/sec] From 6f361f23b365fb07748e383a99a947d29a138629 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 14 May 2024 09:36:36 -0500 Subject: [PATCH 062/115] Clean up use (abuse) of fan airLoopNum --- src/EnergyPlus/Fans.cc | 33 +++++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 8 deletions(-) diff --git a/src/EnergyPlus/Fans.cc b/src/EnergyPlus/Fans.cc index 4df69008478..da6f9d2411c 100644 --- a/src/EnergyPlus/Fans.cc +++ b/src/EnergyPlus/Fans.cc @@ -53,6 +53,7 @@ // EnergyPlus Headers #include +#include #include #include #include @@ -1576,10 +1577,18 @@ void FanComponent::set_size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorEff, Name, motorEff); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatToZoneFrac, Name, 0.0); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, "N/A"); - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchFanAirLoopName, - Name, - airLoopNum > 0 ? state.dataAirSystemsData->PrimaryAirSystems(airLoopNum).Name : "N/A"); + if (airLoopNum == 0) { + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, "N/A"); + } else if (airLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys) { + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, state.dataAirSystemsData->PrimaryAirSystems(airLoopNum).Name); + } else { + OutputReportPredefined::PreDefTableEntry( + state, + state.dataOutRptPredefined->pdchFanAirLoopName, + Name, + state.dataAirLoopHVACDOAS->airloopDOAS[airLoopNum - state.dataHVACGlobal->NumPrimaryAirSys - 1].Name); + } if (nightVentPerfNum > 0) { if (state.dataFans->NightVentPerf(nightVentPerfNum).MaxAirFlowRate == DataSizing::AutoSize) { @@ -2673,10 +2682,18 @@ void FanSystem::set_size(EnergyPlusData &state) state.dataOutRptPredefined->pdchFanMotorHeatZone, Name, heatLossDest == HeatLossDest::Zone ? state.dataHeatBal->Zone(zoneNum).Name : "N/A"); - OutputReportPredefined::PreDefTableEntry(state, - state.dataOutRptPredefined->pdchFanAirLoopName, - Name, - airLoopNum > 0 ? state.dataAirSystemsData->PrimaryAirSystems(airLoopNum).Name : "N/A"); + if (airLoopNum == 0) { + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, "N/A"); + } else if (airLoopNum <= state.dataHVACGlobal->NumPrimaryAirSys) { + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchFanAirLoopName, Name, state.dataAirSystemsData->PrimaryAirSystems(airLoopNum).Name); + } else { + OutputReportPredefined::PreDefTableEntry( + state, + state.dataOutRptPredefined->pdchFanAirLoopName, + Name, + state.dataAirLoopHVACDOAS->airloopDOAS[airLoopNum - state.dataHVACGlobal->NumPrimaryAirSys - 1].Name); + } } Real64 FanSystem::report_fei( From e613e8c433223bde8a57e6c297535ccc3150e223 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 14 May 2024 10:11:08 -0500 Subject: [PATCH 063/115] format --- src/EnergyPlus/Fans.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/Fans.hh b/src/EnergyPlus/Fans.hh index 1df9ca4712b..9941aead8d5 100644 --- a/src/EnergyPlus/Fans.hh +++ b/src/EnergyPlus/Fans.hh @@ -126,7 +126,7 @@ namespace Fans { int outletNodeNum = 0; int airLoopNum = 0; bool airPathFlag = false; // Yes, this fan is a part of airpath - bool isAFNFan = false; // Is fan part of and AirFlowNetwork distribution system + bool isAFNFan = false; // Is fan part of and AirFlowNetwork distribution system Real64 maxAirFlowRate = 0.0; // Max Specified Volume Flow Rate of Fan [m3/sec] Real64 minAirFlowRate = 0.0; // Max Specified Volume Flow Rate of Fan [m3/sec] From e6d44655bbe554a3a751263a0c4412ae0e955186 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Tue, 14 May 2024 12:02:29 -0500 Subject: [PATCH 064/115] set isAFNFan duh --- src/EnergyPlus/AirflowNetwork/src/Solver.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp index 0368356d090..ec5b0901012 100644 --- a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp +++ b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp @@ -10482,8 +10482,13 @@ namespace AirflowNetwork { ->fans(m_state.afn->DisSysCompCVFData(m_state.afn->AirflowNetworkCompData(AirflowNetworkLinkageData(i).CompNum).TypeNum) .FanIndex) ->airLoopNum = AirflowNetworkLinkageData(i).AirLoopNum; + m_state.dataFans + ->fans(m_state.afn->DisSysCompCVFData(m_state.afn->AirflowNetworkCompData(AirflowNetworkLinkageData(i).CompNum).TypeNum) + .FanIndex) + ->isAFNFan = true; } else { m_state.dataFans->fans(n)->airLoopNum = AirflowNetworkLinkageData(i).AirLoopNum; + m_state.dataFans->fans(n)->isAFNFan = true; } } if (AirflowNetworkCompData(AirflowNetworkLinkageData(i).CompNum).EPlusTypeNum == iEPlusComponentType::COI) { From 3f8341d73a9c5eb8efc4f14059ac2bcdd3d509a8 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Wed, 15 May 2024 12:17:52 -0500 Subject: [PATCH 065/115] Fix duplicate plant min volume in eio --- src/EnergyPlus/Plant/PlantManager.cc | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 21f6717c051..72d914258aa 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -3376,18 +3376,20 @@ void SizePlantLoop(EnergyPlusData &state, } } - if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Plant) { - BaseSizer::reportSizerOutput(state, - "PlantLoop", - state.dataPlnt->PlantLoop(LoopNum).Name, - "Minimum Loop Flow Rate [m3/s]", - state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); - } else if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Condenser) { - BaseSizer::reportSizerOutput(state, - "CondenserLoop", - state.dataPlnt->PlantLoop(LoopNum).Name, - "Minimum Loop Flow Rate [m3/s]", - state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); + if (state.dataPlnt->PlantFinalSizesOkayToReport) { + if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Plant) { + BaseSizer::reportSizerOutput(state, + "PlantLoop", + state.dataPlnt->PlantLoop(LoopNum).Name, + "Minimum Loop Flow Rate [m3/s]", + state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); + } else if (state.dataPlnt->PlantLoop(LoopNum).TypeOfLoop == LoopType::Condenser) { + BaseSizer::reportSizerOutput(state, + "CondenserLoop", + state.dataPlnt->PlantLoop(LoopNum).Name, + "Minimum Loop Flow Rate [m3/s]", + state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate); + } } // should now have plant volume, calculate plant volume's mass for fluid type From cc4e6de58f92d1dc3c2658dd3c1f2a0bd03e1d39 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 16 May 2024 10:51:22 -0500 Subject: [PATCH 066/115] Remove columns never populated. --- src/EnergyPlus/OutputReportPredefined.cc | 4 ---- src/EnergyPlus/OutputReportPredefined.hh | 4 ---- 2 files changed, 8 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 0d5e4b754e2..23b5608b75e 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -446,9 +446,6 @@ namespace OutputReportPredefined { s->pdchFanMotorEff = newPreDefColumn(state, s->pdstFan, "Motor Efficiency"); s->pdchFanMotorHeatToZoneFrac = newPreDefColumn(state, s->pdstFan, "Motor Heat to Zone Fraction"); s->pdchFanMotorHeatZone = newPreDefColumn(state, s->pdstFan, "Motor Loss Zone Name"); - s->pdchFanOccOper = newPreDefColumn(state, s->pdstFan, "Occupied Operation"); - s->pdchFanUnoccOper = newPreDefColumn(state, s->pdstFan, "Unoccupied Operation"); - s->pdchFanLockOutDurCentHt = newPreDefColumn(state, s->pdstFan, "Locked Out During Central Heating"); s->pdchFanAirLoopName = newPreDefColumn(state, s->pdstFan, "Airloop Name"); s->pdstPump = newPreDefSubTable(state, s->pdrEquip, "Pumps"); @@ -535,7 +532,6 @@ namespace OutputReportPredefined { s->pdchPLCLProvCool = newPreDefColumn(state, s->pdstPLCL, "Provides Cooling"); s->pdchPLCLMaxLoopFlowRate = newPreDefColumn(state, s->pdstPLCL, "Maximum Loop Flow Rate [m3/s]"); s->pdchPLCLMinLoopFlowRate = newPreDefColumn(state, s->pdstPLCL, "Minimum Loop Flow Rate [m3/s]"); - s->pdchPLCLTotPumpPow = newPreDefColumn(state, s->pdstPLCL, "Total Pump Power on Loop [W]"); // Std 229 Air Terminal Table in Equipment Summary s->pdstAirTerm = newPreDefSubTable(state, s->pdrEquip, "Air Terminals"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 0553d137a89..1eba6db2c5c 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -248,9 +248,6 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchFanMotorEff = 0; int pdchFanMotorHeatToZoneFrac = 0; // Motor Heat to Zone Fraction int pdchFanMotorHeatZone = 0; // Motor Loss Zone Name - int pdchFanOccOper = 0; // Occupied Operation - int pdchFanUnoccOper = 0; // Unoccupied Operation - int pdchFanLockOutDurCentHt = 0; // Locked Out During Central Heating int pdchFanAirLoopName = 0; // Pump subtable @@ -443,7 +440,6 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchPLCLProvCool = 0; // provides cooling int pdchPLCLMaxLoopFlowRate = 0; // Maximum Loop Flow Rate int pdchPLCLMinLoopFlowRate = 0; // Minimum Loop Flow Rate - int pdchPLCLTotPumpPow = 0; // Total Pump Power on Loop // Std 229 Air Terminal Table in Equipment Summary int pdstAirTerm = 0; From 1ca81e26c5c647e74b76151743ef41a49d491ea5 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 10 Jun 2024 06:51:04 -0500 Subject: [PATCH 067/115] Fix to use approach column in equipment table for cooling towers --- src/EnergyPlus/CondenserLoopTowers.cc | 2 +- src/EnergyPlus/FluidCoolers.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index bcc98409f3f..e80346d65b5 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -3427,7 +3427,7 @@ namespace CondenserLoopTowers { this->Name, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName); // Fluid Name more reasonable than FluidType OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCRange, this->Name, this->DesignRange); - OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCRange, this->Name, this->DesignApproach); + OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCApproach, this->Name, this->DesignApproach); OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // eqival to Design Fan Power? OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCDesInletAirWBT, this->Name, this->DesInletAirWBTemp); diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index 9f8b613ddef..cfdd977a1ca 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -1636,7 +1636,7 @@ void FluidCoolerspecs::size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCRange, this->Name, this->DesignEnteringWaterTemp - this->DesignLeavingWaterTemp); OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchCTFCRange, this->Name, this->DesignLeavingWaterTemp - this->DesignEnteringAirWetBulbTemp); + state, state.dataOutRptPredefined->pdchCTFCApproach, this->Name, this->DesignLeavingWaterTemp - this->DesignEnteringAirWetBulbTemp); OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // eqival to Design Fan Power? OutputReportPredefined::PreDefTableEntry( From 3b43b8e19d3d7648e3b423e65220487da46785db Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 10 Jun 2024 07:28:39 -0500 Subject: [PATCH 068/115] Save design leaving water temperature for equipment reporting. --- src/EnergyPlus/FluidCoolers.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index cfdd977a1ca..1f4601b9296 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -979,6 +979,7 @@ void FluidCoolerspecs::size(EnergyPlusData &state) this->DesignWaterFlowRate); } } + this->DesignLeavingWaterTemp = state.dataSize->PlantSizData(PltSizCondNum).ExitTemp; } else { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { ShowSevereError(state, format("Autosizing error for fluid cooler object = {}", this->Name)); From 4b2742e68dc83032e965e16976db2861ba89ec71 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 10 Jun 2024 08:23:03 -0500 Subject: [PATCH 069/115] formatting --- src/EnergyPlus/CondenserLoopTowers.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index e80346d65b5..c5438734996 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -5359,7 +5359,7 @@ namespace CondenserLoopTowers { } // IF(OutletWaterTempMIN .LT. TempSetPoint)THEN } // IF(OutletWaterTempOFF .GT. TempSetPoint)THEN - } // IF(OutletWaterTempON .LT. TempSetPoint) ie if tower should not run at full capacity + } // IF(OutletWaterTempON .LT. TempSetPoint) ie if tower should not run at full capacity Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, From 481cc078fc421fd318293049c8abe15a7e91019c Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 10 Jun 2024 08:35:15 -0500 Subject: [PATCH 070/115] Remove some old FORTRAN code in comments that was messing up Clang format --- src/EnergyPlus/CondenserLoopTowers.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index c5438734996..dfd6f8f7b5b 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -5356,10 +5356,9 @@ namespace CondenserLoopTowers { } // outlet water temperature is calculated as the inlet air wet-bulb temperature plus tower approach temperature this->OutletWaterTemp = Twb + Ta; - } // IF(OutletWaterTempMIN .LT. TempSetPoint)THEN - - } // IF(OutletWaterTempOFF .GT. TempSetPoint)THEN - } // IF(OutletWaterTempON .LT. TempSetPoint) ie if tower should not run at full capacity + } + } + } Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, From 5d4b8d2c95d40bfe8d8be8266e76ad12e1e1e9e8 Mon Sep 17 00:00:00 2001 From: amirroth Date: Wed, 26 Jun 2024 08:02:10 -0400 Subject: [PATCH 071/115] namespace Fluid --- src/EnergyPlus/AirLoopHVACDOAS.cc | 6 +- .../CoolingWaterDesAirOutletTempSizing.cc | 4 +- .../Autosizing/CoolingWaterflowSizing.cc | 8 +- .../HeatingWaterDesCoilLoadUsedForUASizing.cc | 12 +- .../Autosizing/HeatingWaterflowSizing.cc | 8 +- .../Autosizing/WaterHeatingCapacitySizing.cc | 8 +- src/EnergyPlus/BaseboardRadiator.cc | 4 +- src/EnergyPlus/BoilerSteam.cc | 40 +- src/EnergyPlus/Boilers.cc | 8 +- src/EnergyPlus/CTElectricGenerator.cc | 4 +- src/EnergyPlus/ChilledCeilingPanelSimple.cc | 14 +- src/EnergyPlus/ChillerAbsorption.cc | 52 +- src/EnergyPlus/ChillerElectricASHRAE205.cc | 26 +- src/EnergyPlus/ChillerElectricEIR.cc | 24 +- src/EnergyPlus/ChillerExhaustAbsorption.cc | 20 +- src/EnergyPlus/ChillerGasAbsorption.cc | 20 +- src/EnergyPlus/ChillerIndirectAbsorption.cc | 54 +- src/EnergyPlus/ChillerReformulatedEIR.cc | 26 +- src/EnergyPlus/CondenserLoopTowers.cc | 88 +- src/EnergyPlus/Data/EnergyPlusData.cc | 6 +- src/EnergyPlus/Data/EnergyPlusData.hh | 4 +- src/EnergyPlus/DaylightingDevices.cc | 2 +- src/EnergyPlus/DesiccantDehumidifiers.cc | 12 +- src/EnergyPlus/EvaporativeFluidCoolers.cc | 42 +- src/EnergyPlus/FanCoilUnits.cc | 12 +- src/EnergyPlus/FluidCoolers.cc | 32 +- src/EnergyPlus/FluidProperties.cc | 1850 ++++++++--------- src/EnergyPlus/FluidProperties.hh | 22 +- src/EnergyPlus/FuelCellElectricGenerator.cc | 4 +- src/EnergyPlus/Furnaces.cc | 26 +- src/EnergyPlus/GroundHeatExchangers.cc | 30 +- src/EnergyPlus/HVACControllers.cc | 2 +- src/EnergyPlus/HVACCooledBeam.cc | 10 +- src/EnergyPlus/HVACFourPipeBeam.cc | 20 +- src/EnergyPlus/HVACInterfaceManager.cc | 6 +- src/EnergyPlus/HVACMultiSpeedHeatPump.cc | 24 +- src/EnergyPlus/HVACSingleDuctInduc.cc | 12 +- src/EnergyPlus/HVACSizingSimulationManager.cc | 4 +- src/EnergyPlus/HVACUnitaryBypassVAV.cc | 10 +- src/EnergyPlus/HVACVariableRefrigerantFlow.cc | 162 +- src/EnergyPlus/HWBaseboardRadiator.cc | 16 +- src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc | 26 +- src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc | 26 +- src/EnergyPlus/HeatPumpWaterToWaterSimple.cc | 48 +- src/EnergyPlus/Humidifiers.cc | 16 +- src/EnergyPlus/ICEngineElectricGenerator.cc | 4 +- src/EnergyPlus/IceThermalStorage.cc | 6 +- src/EnergyPlus/LowTempRadiantSystem.cc | 20 +- src/EnergyPlus/MicroCHPElectricGenerator.cc | 8 +- .../MicroturbineElectricGenerator.cc | 6 +- src/EnergyPlus/NodeInputManager.cc | 12 +- src/EnergyPlus/OutdoorAirUnit.cc | 7 +- src/EnergyPlus/OutsideEnergySources.cc | 22 +- src/EnergyPlus/PackagedThermalStorageCoil.cc | 34 +- .../PhotovoltaicThermalCollectors.cc | 2 +- src/EnergyPlus/PipeHeatTransfer.cc | 8 +- src/EnergyPlus/Plant/EquipAndOperations.cc | 10 +- src/EnergyPlus/Plant/Loop.cc | 10 +- src/EnergyPlus/Plant/LoopSide.cc | 13 +- src/EnergyPlus/Plant/PlantManager.cc | 31 +- src/EnergyPlus/PlantCentralGSHP.cc | 32 +- src/EnergyPlus/PlantChillers.cc | 78 +- .../PlantComponentTemperatureSources.cc | 6 +- src/EnergyPlus/PlantCondLoopOperation.cc | 4 +- .../PlantHeatExchangerFluidToFluid.cc | 20 +- src/EnergyPlus/PlantLoadProfile.cc | 20 +- src/EnergyPlus/PlantLoopHeatPumpEIR.cc | 40 +- src/EnergyPlus/PlantPipingSystemsManager.cc | 10 +- src/EnergyPlus/PlantPressureSystem.cc | 8 +- src/EnergyPlus/PlantUtilities.cc | 4 +- src/EnergyPlus/PondGroundHeatExchanger.cc | 32 +- src/EnergyPlus/PoweredInductionUnits.cc | 19 +- src/EnergyPlus/Pumps.cc | 22 +- src/EnergyPlus/RefrigeratedCase.cc | 172 +- src/EnergyPlus/ReportCoilSelection.cc | 16 +- src/EnergyPlus/RoomAirModelUserTempPattern.cc | 2 +- src/EnergyPlus/SetPointManager.cc | 2 +- src/EnergyPlus/SimulationManager.cc | 2 +- src/EnergyPlus/SingleDuct.cc | 15 +- src/EnergyPlus/SolarCollectors.cc | 24 +- src/EnergyPlus/StandardRatings.cc | 4 +- src/EnergyPlus/SteamBaseboardRadiator.cc | 18 +- src/EnergyPlus/SteamCoils.cc | 43 +- src/EnergyPlus/SurfaceGroundHeatExchanger.cc | 10 +- src/EnergyPlus/SwimmingPool.cc | 8 +- src/EnergyPlus/UnitHeater.cc | 15 +- src/EnergyPlus/UnitVentilator.cc | 22 +- src/EnergyPlus/UnitarySystem.cc | 36 +- src/EnergyPlus/UserDefinedComponents.cc | 16 +- src/EnergyPlus/VariableSpeedCoils.cc | 26 +- src/EnergyPlus/VentilatedSlab.cc | 17 +- src/EnergyPlus/WaterCoils.cc | 4 +- src/EnergyPlus/WaterThermalTanks.cc | 110 +- src/EnergyPlus/WaterToAirHeatPump.cc | 83 +- src/EnergyPlus/WaterToAirHeatPumpSimple.cc | 10 +- src/EnergyPlus/WaterUse.cc | 2 +- src/EnergyPlus/api/EnergyPlusPgm.cc | 2 +- src/EnergyPlus/api/func.cc | 28 +- tst/EnergyPlus/unit/BoilerHotWater.unit.cc | 4 +- tst/EnergyPlus/unit/ChillerAbsorption.unit.cc | 12 +- .../unit/ChillerExhaustAbsorption.unit.cc | 2 +- .../unit/Fixtures/EnergyPlusFixture.cc | 6 +- tst/EnergyPlus/unit/FluidProperties.unit.cc | 47 +- .../unit/HVACVariableRefrigerantFlow.unit.cc | 13 +- .../unit/HWBaseboardRadiator.unit.cc | 1 - .../unit/LowTempRadiantSystem.unit.cc | 17 +- tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc | 13 +- .../unit/OutsideEnergySources.unit.cc | 12 +- tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc | 8 +- tst/EnergyPlus/unit/PlantLoadProfile.unit.cc | 12 +- tst/EnergyPlus/unit/SetPointManager.unit.cc | 4 +- tst/EnergyPlus/unit/UnitHeater.unit.cc | 7 +- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 2 +- tst/EnergyPlus/unit/WaterCoils.unit.cc | 51 +- tst/EnergyPlus/unit/WaterThermalTanks.unit.cc | 13 +- .../unit/WaterToAirHeatPump.unit.cc | 112 +- 116 files changed, 2161 insertions(+), 2200 deletions(-) diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc index 2db751c59d2..16a97ba7cbf 100644 --- a/src/EnergyPlus/AirLoopHVACDOAS.cc +++ b/src/EnergyPlus/AirLoopHVACDOAS.cc @@ -889,7 +889,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:HEATING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_HeatCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", CompName, ErrorsFound); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -903,7 +903,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:COOLING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water", CompName, ErrorsFound); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -918,7 +918,7 @@ namespace AirLoopHVACDOAS { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", CompName, ErrorsFound); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc index 5afba936626..1eabcdf2ffa 100644 --- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc +++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc @@ -66,12 +66,12 @@ Real64 CoolingWaterDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _or this->autoSizedValue = _originalValue; } else { if (this->termUnitIU) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc index 4725b24c5d1..1a6761c9818 100644 --- a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc +++ b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc @@ -88,12 +88,12 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (DesCoilLoad >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizCoolDeltaT > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -120,12 +120,12 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (this->curOASysNum > 0) CoilDesWaterDeltaT *= 0.5; if (this->dataCapacityUsedForSizing >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && CoilDesWaterDeltaT > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc index 336dc37c5d3..ce84da3ffc6 100644 --- a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc +++ b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc @@ -69,12 +69,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = _originalValue; } else { if (this->termUnitSingDuct && (this->curTermUnitSizingNum > 0)) { - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -82,12 +82,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho; state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(state, this->compName, this->compType, 1.0); } else if ((this->termUnitPIU || this->termUnitIU) && (this->curTermUnitSizingNum > 0)) { - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -95,12 +95,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho * this->termUnitSizing(this->curTermUnitSizingNum).ReheatLoadMult; } else if (this->zoneEqFanCoil || this->zoneEqUnitHeater) { - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc index 823f2c00aa3..30e724a0a60 100644 --- a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc +++ b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc @@ -93,12 +93,12 @@ Real64 HeatingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (DesCoilLoad >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizHeatDeltaT > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -123,12 +123,12 @@ Real64 HeatingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (this->dataCapacityUsedForSizing >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizHeatDeltaT > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc index 342293b358a..a0193390ae9 100644 --- a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc +++ b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc @@ -72,12 +72,12 @@ Real64 WaterHeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalVa Real64 CoilOutHumRat = 0.0; if ((this->termUnitSingDuct || this->termUnitPIU || this->termUnitIU) && (this->curTermUnitSizingNum > 0)) { DesMassFlow = this->termUnitSizing(this->curTermUnitSizingNum).MaxHWVolFlow; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -85,12 +85,12 @@ Real64 WaterHeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalVa NominalCapacityDes = DesMassFlow * this->dataWaterCoilSizHeatDeltaT * Cp * rho; } else if (this->zoneEqFanCoil || this->zoneEqUnitHeater) { DesMassFlow = this->zoneEqSizing(this->curZoneEqNum).MaxHWVolFlow; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/BaseboardRadiator.cc b/src/EnergyPlus/BaseboardRadiator.cc index 62ee9c5446a..2f448c4674c 100644 --- a/src/EnergyPlus/BaseboardRadiator.cc +++ b/src/EnergyPlus/BaseboardRadiator.cc @@ -95,8 +95,8 @@ namespace BaseboardRadiator { // Use statements for access to subroutines in other modules using namespace ScheduleManager; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyRhoAirFnPbTdbW; diff --git a/src/EnergyPlus/BoilerSteam.cc b/src/EnergyPlus/BoilerSteam.cc index ac806e920ae..97f96a35edc 100644 --- a/src/EnergyPlus/BoilerSteam.cc +++ b/src/EnergyPlus/BoilerSteam.cc @@ -267,7 +267,7 @@ namespace BoilerSteam { "Hot Steam Nodes"); if (SteamFluidIndex == 0 && BoilerNum == 1) { - SteamFluidIndex = FluidProperties::FindRefrigerant(state, fluidNameSteam); + SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); if (SteamFluidIndex == 0) { ShowSevereError( state, format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); @@ -307,13 +307,13 @@ namespace BoilerSteam { int BoilerInletNode = this->BoilerInletNodeNum; Real64 EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 1.0, this->FluidIndex, RoutineName); Real64 EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); Real64 LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; Real64 CpWater = - FluidProperties::GetSatSpecificHeatRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); this->DesMassFlowRate = this->NomCap / (LatentEnthSteam + CpWater * (this->TempUpLimitBoilerOut - state.dataLoopNodes->Node(BoilerInletNode).Temp)); @@ -500,11 +500,11 @@ namespace BoilerSteam { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { Real64 SizingTemp = this->TempUpLimitBoilerOut; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); Real64 LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; - Real64 CpWater = FluidProperties::GetSatSpecificHeatRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); + Real64 CpWater = Fluid::GetSatSpecificHeatRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); tmpNomCap = (CpWater * SteamDensity * this->SizFac * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate + state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate * SteamDensity * LatentEnthSteam); @@ -677,7 +677,7 @@ namespace BoilerSteam { // Set the current load equal to the boiler load this->BoilerLoad = MyLoad; - this->BoilerPressCheck = FluidProperties::GetSatPressureRefrig(state, fluidNameSteam, this->BoilerOutletTemp, this->FluidIndex, RoutineName); + this->BoilerPressCheck = Fluid::GetSatPressureRefrig(state, fluidNameSteam, this->BoilerOutletTemp, this->FluidIndex, RoutineName); if ((this->BoilerPressCheck) > this->BoilerMaxOperPress) { if (this->PressErrIndex == 0) { @@ -697,7 +697,7 @@ namespace BoilerSteam { "[Pa]"); } - CpWater = FluidProperties::GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp, 0.0, this->FluidIndex, RoutineName); if (state.dataPlnt->PlantLoop(this->plantLoc.loopNum).LoopSide(this->plantLoc.loopSideNum).FlowLock == @@ -717,9 +717,9 @@ namespace BoilerSteam { this->BoilerOutletTemp = BoilerDeltaTemp + state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; Real64 const EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + (CpWater * BoilerDeltaTemp)); @@ -755,9 +755,9 @@ namespace BoilerSteam { break; } Real64 const EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerLoad = (this->BoilerMassFlowRate * LatentEnthSteam); @@ -774,9 +774,9 @@ namespace BoilerSteam { } Real64 const EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerLoad = std::abs(this->BoilerMassFlowRate * LatentEnthSteam) + std::abs(this->BoilerMassFlowRate * CpWater * BoilerDeltaTemp); @@ -799,9 +799,9 @@ namespace BoilerSteam { } Real64 const EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; BoilerDeltaTemp = this->BoilerOutletTemp - state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + CpWater * BoilerDeltaTemp); @@ -816,9 +816,9 @@ namespace BoilerSteam { this->BoilerLoad = this->NomCap; Real64 const EnthSteamOutDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; BoilerDeltaTemp = this->BoilerOutletTemp - state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + CpWater * BoilerDeltaTemp); diff --git a/src/EnergyPlus/Boilers.cc b/src/EnergyPlus/Boilers.cc index d76186b5476..fbc339adbe9 100644 --- a/src/EnergyPlus/Boilers.cc +++ b/src/EnergyPlus/Boilers.cc @@ -507,7 +507,7 @@ void BoilerSpecs::oneTimeInit(EnergyPlusData &state) void BoilerSpecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("BoilerSpecs::initEachEnvironment"); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -624,12 +624,12 @@ void BoilerSpecs::SizeBoiler(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -815,7 +815,7 @@ void BoilerSpecs::CalcBoilerModel(EnergyPlusData &state, Real64 const TempUpLimitBout = this->TempUpLimitBoilerOut; // C - boiler high temperature limit Real64 const BoilerMassFlowRateMax = this->DesMassFlowRate; // Max Design Boiler Mass Flow Rate converted from Volume Flow Rate - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(BoilerInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/CTElectricGenerator.cc b/src/EnergyPlus/CTElectricGenerator.cc index db8b1b92d94..42d25551956 100644 --- a/src/EnergyPlus/CTElectricGenerator.cc +++ b/src/EnergyPlus/CTElectricGenerator.cc @@ -555,7 +555,7 @@ namespace CTElectricGenerator { int heatRecInNode = this->HeatRecInletNodeNum; heatRecInTemp = state.dataLoopNodes->Node(heatRecInNode).Temp; - heatRecCp = FluidProperties::GetSpecificHeatGlycol(state, + heatRecCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -810,7 +810,7 @@ namespace CTElectricGenerator { int HeatRecOutletNode = this->HeatRecOutletNodeNum; // size mass flow rate - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChilledCeilingPanelSimple.cc b/src/EnergyPlus/ChilledCeilingPanelSimple.cc index 811b5aead15..537951000a7 100644 --- a/src/EnergyPlus/ChilledCeilingPanelSimple.cc +++ b/src/EnergyPlus/ChilledCeilingPanelSimple.cc @@ -830,7 +830,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons // set design mass flow rates if (thisCP.WaterInletNode > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -845,7 +845,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons if (state.dataGlobal->BeginEnvrnFlag && thisCP.MyEnvrnFlag) { // Initialize - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -857,7 +857,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons ThisInNode.Temp = 7.0; - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, ThisInNode.Temp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -1032,12 +1032,12 @@ void SizeCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum) PlantUtilities::MyPlantSizingIndex(state, CompType, thisCP.Name, thisCP.WaterInletNode, thisCP.WaterOutletNode, ErrorsFound); if (PltSizCoolNum > 0) { if (DesCoilLoad >= HVAC::SmallLoad) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -1290,7 +1290,7 @@ void CoolingPanelParams::CalcCoolingPanel(EnergyPlusData &state, int const Cooli if (QZnReq < -HVAC::SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) && (CoolingPanelOn)) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, waterInletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1375,7 +1375,7 @@ void CoolingPanelParams::CalcCoolingPanel(EnergyPlusData &state, int const Cooli if (CoolingPanelOn) { // Now simulate the system... - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, waterInletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerAbsorption.cc b/src/EnergyPlus/ChillerAbsorption.cc index c0ba8f94fcb..b18c7dd084b 100644 --- a/src/EnergyPlus/ChillerAbsorption.cc +++ b/src/EnergyPlus/ChillerAbsorption.cc @@ -385,7 +385,7 @@ void GetBLASTAbsorberInput(EnergyPlusData &state) state.dataIPShortCut->cAlphaArgs(7), "Hot Water Nodes"); } else { - thisChiller.SteamFluidIndex = FluidProperties::FindRefrigerant(state, fluidNameSteam); + thisChiller.SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); thisChiller.GeneratorInletNodeNum = NodeInputManager::GetOnlySingleNode(state, state.dataIPShortCut->cAlphaArgs(6), ErrorsFound, @@ -755,7 +755,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) constexpr const char *RoutineName("BLASTAbsorberSpecs::initEachEnvironment"); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -765,7 +765,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -779,7 +779,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) if (this->GeneratorInletNodeNum > 0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -791,7 +791,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) this->QGenerator = (this->SteamLoadCoef[0] + this->SteamLoadCoef[1] + this->SteamLoadCoef[2]) * this->NomCap; // dry enthalpy of steam (quality = 1) - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -799,7 +799,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) calcChillerAbsorption + this->Name); // wet enthalpy of steam (quality = 0) - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -810,7 +810,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; int curWaterIndex = waterIndex; Real64 CpWater = - FluidProperties::GetDensityGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); + Fluid::GetDensityGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); this->GenMassFlowRateMax = this->QGenerator / (HfgSteam + CpWater * SteamDeltaT); } @@ -952,13 +952,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1120,13 +1120,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { // QCondenser = QEvaporator + QGenerator + PumpingPower - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1198,13 +1198,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water)) { if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); Real64 SteamDeltaT = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); - Real64 RhoWater = FluidProperties::GetDensityGlycol(state, + Real64 RhoWater = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1259,25 +1259,25 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) } } else { constexpr const char *RoutineNameLong("SizeAbsorptionChiller"); - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( + Real64 SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, this->SteamFluidIndex, RoutineNameLong); Real64 SteamDeltaT = state.dataSize->PlantSizData(PltSizSteamNum).DeltaT; Real64 GeneratorOutletTemp = state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp - SteamDeltaT; - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, this->SteamFluidIndex, moduleObjectType + this->Name); - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 0.0, this->SteamFluidIndex, moduleObjectType + this->Name); int curWaterIndex = waterIndex; - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, curWaterIndex, RoutineName); + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, curWaterIndex, RoutineName); Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; this->SteamMassFlowRate = (this->NomCap * SteamInputRatNom) / ((HfgSteam) + (SteamDeltaT * CpWater)); tmpGeneratorVolFlowRate = this->SteamMassFlowRate / SteamDensity; @@ -1366,12 +1366,12 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) this->GeneratorDeltaTemp = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1485,7 +1485,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R Real64 TempEvapOut = state.dataLoopNodes->Node(this->EvapOutletNodeNum).Temp; - Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1715,7 +1715,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R this->QCondenser = this->QEvaporator + this->QGenerator + this->PumpingPower; - CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->CondInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1736,7 +1736,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { Real64 GenMassFlowRate = 0.0; // Hot water plant is used for the generator - CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, state.dataPlnt->PlantLoop(GenPlantLoc.loopNum).FluidIndex, @@ -1771,7 +1771,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R } else { // using a steam plant for the generator // enthalpy of dry steam at generator inlet - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -1779,7 +1779,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R calcChillerAbsorption + this->Name); // enthalpy of wet steam at generator inlet - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -1790,7 +1790,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; int curWaterIndex = waterIndex; CpFluid = - FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); + Fluid::GetSpecificHeatGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); this->SteamMassFlowRate = this->QGenerator / (HfgSteam + CpFluid * SteamDeltaT); PlantUtilities::SetComponentFlowRate( state, this->SteamMassFlowRate, this->GeneratorInletNodeNum, this->GeneratorOutletNodeNum, this->GenPlantLoc); @@ -1800,7 +1800,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R this->SteamOutletEnthalpy = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Enthalpy; } else { this->GenOutletTemp = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp - SteamDeltaT; - this->SteamOutletEnthalpy = FluidProperties::GetSatEnthalpyRefrig( + this->SteamOutletEnthalpy = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, this->GenOutletTemp, 0.0, this->SteamFluidIndex, moduleObjectType + this->Name); this->SteamOutletEnthalpy -= CpFluid * SteamDeltaT; } diff --git a/src/EnergyPlus/ChillerElectricASHRAE205.cc b/src/EnergyPlus/ChillerElectricASHRAE205.cc index b3413b28b48..cdbe6631f0c 100644 --- a/src/EnergyPlus/ChillerElectricASHRAE205.cc +++ b/src/EnergyPlus/ChillerElectricASHRAE205.cc @@ -596,7 +596,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag this->EquipFlowCtrl = DataPlant::CompData::getPlantComponent(state, this->CWPlantLoc).FlowCtrl; if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -606,7 +606,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -617,7 +617,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag } // Set mass flow rates at Oil Cooler and Aux Equipment nodes if (this->OilCoolerInletNode) { - Real64 rho_oil_cooler = FluidProperties::GetDensityGlycol(state, + Real64 rho_oil_cooler = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidIndex, @@ -626,7 +626,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag PlantUtilities::InitComponentNodes(state, 0.0, this->OilCoolerMassFlowRate, this->OilCoolerInletNode, this->OilCoolerOutletNode); } if (this->AuxiliaryHeatInletNode) { - Real64 rho_aux = FluidProperties::GetDensityGlycol(state, + Real64 rho_aux = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidIndex, @@ -771,12 +771,12 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -878,13 +878,13 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1256,7 +1256,7 @@ void ASHRAE205ChillerSpecs::findEvaporatorMassFlowRate(EnergyPlusData &state, Re } } // This is the end of the FlowLock Block - const Real64 rho = FluidProperties::GetDensityGlycol(state, + const Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1391,7 +1391,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo return; } - Real64 CpEvap = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpEvap = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1508,7 +1508,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo // Energy balance on the chiller system gives the amount of heat lost to the ambient zone this->AmbientZoneGain = this->QEvaporator + this->Power - (this->QCondenser + QExternallyCooled); - Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1521,7 +1521,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo PlantUtilities::SetComponentFlowRate( state, this->OilCoolerMassFlowRate, this->OilCoolerInletNode, this->OilCoolerOutletNode, this->OCPlantLoc); - Real64 CpOilCooler = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpOilCooler = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->OilCoolerInletNode).Temp, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidIndex, @@ -1539,7 +1539,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo PlantUtilities::SetComponentFlowRate( state, this->AuxiliaryMassFlowRate, this->AuxiliaryHeatInletNode, this->AuxiliaryHeatOutletNode, this->AHPlantLoc); - Real64 CpAux = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpAux = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->AuxiliaryHeatInletNode).Temp, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerElectricEIR.cc b/src/EnergyPlus/ChillerElectricEIR.cc index 0c771b352b6..3d43f2dfb25 100644 --- a/src/EnergyPlus/ChillerElectricEIR.cc +++ b/src/EnergyPlus/ChillerElectricEIR.cc @@ -1152,7 +1152,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) static constexpr std::string_view RoutineName("ElectricEIRChillerSpecs::initEachEnvironment"); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1164,7 +1164,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1190,7 +1190,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) } if (this->HeatRecActive) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1405,13 +1405,13 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1468,12 +1468,12 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1995,7 +1995,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b if (DataPlant::CompData::getPlantComponent(state, this->CWPlantLoc).CurOpSchemeType == DataPlant::OpScheme::CompSetPtBased) { // Calculate water side load - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2028,7 +2028,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b PartLoadRat = max(0.0, min(std::abs(MyLoad) / AvailChillerCap, this->MaxPartLoadRat)); } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2300,7 +2300,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovered); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2369,14 +2369,14 @@ void ElectricEIRChillerSpecs::calcHeatRecovery(EnergyPlusData &state, Real64 heatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, RoutineName); Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = FluidProperties::GetSpecificHeatGlycol(state, + CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerExhaustAbsorption.cc b/src/EnergyPlus/ChillerExhaustAbsorption.cc index e29f2a10fbf..15db9f07583 100644 --- a/src/EnergyPlus/ChillerExhaustAbsorption.cc +++ b/src/EnergyPlus/ChillerExhaustAbsorption.cc @@ -949,7 +949,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) if (this->isWaterCooled) { // init max available condenser water flow rate if (this->CDPlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -963,7 +963,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) } if (this->HWPlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -976,7 +976,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->DesHeatMassFlowRate, HeatInletNode, HeatOutletNode); if (this->CWPlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1066,12 +1066,12 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1296,12 +1296,12 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1542,13 +1542,13 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) Real64 lExhaustInFlow = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).MassFlowRate; Real64 lExhaustAirHumRat = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).HumRat; - Real64 Cp_CW = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp_CW = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); if (this->CDPlantLoc.loopNum > 0) { - Cp_CD = FluidProperties::GetSpecificHeatGlycol(state, + Cp_CD = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1906,7 +1906,7 @@ void ExhaustAbsorberSpecs::calcHeater(EnergyPlusData &state, Real64 &MyLoad, boo } else { Real64 const Cp_HW = - FluidProperties::GetSpecificHeatGlycol(state, hwPlantLoop.FluidName, heatReturnNode.Temp, hwPlantLoop.FluidIndex, RoutineName); + Fluid::GetSpecificHeatGlycol(state, hwPlantLoop.FluidName, heatReturnNode.Temp, hwPlantLoop.FluidIndex, RoutineName); // Determine available heating capacity using the current cooling load lAvailableHeatingCapacity = this->NomHeatCoolRatio * this->NomCoolingCap * diff --git a/src/EnergyPlus/ChillerGasAbsorption.cc b/src/EnergyPlus/ChillerGasAbsorption.cc index 6cb26c946db..effb063112e 100644 --- a/src/EnergyPlus/ChillerGasAbsorption.cc +++ b/src/EnergyPlus/ChillerGasAbsorption.cc @@ -948,7 +948,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) if (this->isWaterCooled) { // init max available condenser water flow rate if (this->CDplantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -962,7 +962,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) } if (this->HWplantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, @@ -975,7 +975,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->DesHeatMassFlowRate, HeatInletNode, HeatOutletNode); if (this->CWplantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1059,12 +1059,12 @@ void GasAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1288,12 +1288,12 @@ void GasAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -1532,7 +1532,7 @@ void GasAbsorberSpecs::calculateChiller(EnergyPlusData &state, Real64 &MyLoad) Real64 ChillDeltaTemp = std::abs(lChillReturnTemp - ChillSupplySetPointTemp); // local fluid specific heat for chilled water - Real64 Cp_CW = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp_CW = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1540,7 +1540,7 @@ void GasAbsorberSpecs::calculateChiller(EnergyPlusData &state, Real64 &MyLoad) // local fluid specific heat for condenser water Real64 Cp_CD = 0; // putting this here as a dummy initialization to hush the compiler warning, in real runs this value should never be used if (this->CDplantLoc.loopNum > 0) { - Cp_CD = FluidProperties::GetSpecificHeatGlycol(state, + Cp_CD = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -1854,7 +1854,7 @@ void GasAbsorberSpecs::calculateHeater(EnergyPlusData &state, Real64 &MyLoad, bo LoopNum = this->HWplantLoc.loopNum; LoopSideNum = this->HWplantLoc.loopSideNum; - Cp_HW = FluidProperties::GetSpecificHeatGlycol( + Cp_HW = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, lHotWaterReturnTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); lCoolElectricPower = this->CoolElectricPower; diff --git a/src/EnergyPlus/ChillerIndirectAbsorption.cc b/src/EnergyPlus/ChillerIndirectAbsorption.cc index 5081ea1f74b..4652293bf4f 100644 --- a/src/EnergyPlus/ChillerIndirectAbsorption.cc +++ b/src/EnergyPlus/ChillerIndirectAbsorption.cc @@ -396,7 +396,7 @@ void GetIndirectAbsorberInput(EnergyPlusData &state) state.dataIPShortCut->cAlphaArgs(10), "Hot Water Nodes"); } else { - thisChiller.SteamFluidIndex = FluidProperties::FindRefrigerant(state, fluidNameSteam); + thisChiller.SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); thisChiller.GeneratorInletNodeNum = NodeInputManager::GetOnlySingleNode(state, state.dataIPShortCut->cAlphaArgs(9), ErrorsFound, @@ -891,7 +891,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real // Initialize Supply Side Variables if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -901,7 +901,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -917,7 +917,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -925,7 +925,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real this->GenMassFlowRateMax = rho * this->GeneratorVolFlowRate; } else { - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -1052,13 +1052,13 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1240,13 +1240,13 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { // QCondenser = QEvaporator + QGenerator + PumpingPower - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1331,14 +1331,14 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water)) { if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); Real64 SteamDeltaT = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); - Real64 RhoWater = FluidProperties::GetDensityGlycol(state, + Real64 RhoWater = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1395,7 +1395,7 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) } } } else { - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, @@ -1405,7 +1405,7 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) Real64 GeneratorOutletTemp = state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp - SteamDeltaT; // dry enthalpy of steam (quality = 1) - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, @@ -1413,14 +1413,14 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) std::string{SizeChillerAbsorptionIndirect} + this->Name); // wet enthalpy of steam (quality = 0) - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 0.0, this->SteamFluidIndex, std::string{SizeChillerAbsorptionIndirect} + this->Name); Real64 CpWater = - FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, const_cast(waterIndex), RoutineName); + Fluid::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, const_cast(waterIndex), RoutineName); Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; // calculate the mass flow rate through the generator Real64 SteamMassFlowRate = (tmpNomCap * SteamInputRatNom) / ((HfgSteam) + (SteamDeltaT * CpWater)); @@ -1519,12 +1519,12 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { this->GeneratorDeltaTemp = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1717,7 +1717,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // C - Evaporator low temp. limit cut off Real64 TempLowLimitEout = this->TempLowLimitEvapOut; - Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1987,7 +1987,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad this->QCondenser = this->QEvaporator + this->QGenerator + this->PumpingPower; - CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2007,7 +2007,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // Hot water plant is used for the generator if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -2034,7 +2034,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad } else { // using a steam plant for the generator // enthalpy of dry steam at generator inlet - Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -2042,7 +2042,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad std::string{calcChillerAbsorptionIndirect} + this->Name); // enthalpy of wet steam at generator inlet - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -2057,7 +2057,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // heat of vaporization of steam Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; - CpFluid = FluidProperties::GetSpecificHeatGlycol( + CpFluid = Fluid::GetSpecificHeatGlycol( state, fluidNameWater, SteamOutletTemp, const_cast(waterIndex), std::string{calcChillerAbsorptionIndirect} + this->Name); this->GenMassFlowRate = this->QGenerator / (HfgSteam + CpFluid * SteamDeltaT); PlantUtilities::SetComponentFlowRate( @@ -2068,13 +2068,13 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad this->SteamOutletEnthalpy = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Enthalpy; } else { this->GenOutletTemp = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp - SteamDeltaT; - this->SteamOutletEnthalpy = FluidProperties::GetSatEnthalpyRefrig(state, + this->SteamOutletEnthalpy = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, this->SteamFluidIndex, std::string{LoopLossesChillerAbsorptionIndirect} + this->Name); - CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + CpFluid = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, const_cast(waterIndex), @@ -2085,14 +2085,14 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad //************************* Loop Losses ***************************** // temperature of condensed steam leaving generator (after condensate trap) - Real64 TempWaterAtmPress = FluidProperties::GetSatTemperatureRefrig(state, + Real64 TempWaterAtmPress = Fluid::GetSatTemperatureRefrig(state, fluidNameSteam, state.dataEnvrn->OutBaroPress, this->SteamFluidIndex, std::string{LoopLossesChillerAbsorptionIndirect} + this->Name); // enthalpy of condensed steam leaving generator (after condensate trap) - Real64 EnthAtAtmPress = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempWaterAtmPress, 0.0, diff --git a/src/EnergyPlus/ChillerReformulatedEIR.cc b/src/EnergyPlus/ChillerReformulatedEIR.cc index fced4b2388a..6b5d6d6210e 100644 --- a/src/EnergyPlus/ChillerReformulatedEIR.cc +++ b/src/EnergyPlus/ChillerReformulatedEIR.cc @@ -990,7 +990,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1002,7 +1002,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1027,7 +1027,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R } if (this->HeatRecActive) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1197,12 +1197,12 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) SizingEvapOutletTemp = state.dataSize->PlantSizData(PltSizNum).ExitTemp; SizingCondOutletTemp = state.dataSize->PlantSizData(PltSizCondNum).ExitTemp + state.dataSize->PlantSizData(PltSizCondNum).DeltaT; } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1263,12 +1263,12 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0 && this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1607,13 +1607,13 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) } // Initialize condenser reference inlet temperature (not a user input) - Real64 Density = FluidProperties::GetDensityGlycol(state, + Real64 Density = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondOut, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol(state, + Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondOut, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1846,14 +1846,14 @@ void ReformulatedEIRChillerSpecs::calcHeatRecovery(EnergyPlusData &state, Real64 heatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, RoutineName); Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = FluidProperties::GetSpecificHeatGlycol(state, + CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2158,7 +2158,7 @@ void ReformulatedEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoa // This chiller is currently has only a water-cooled condenser // Calculate water side load - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2442,7 +2442,7 @@ void ReformulatedEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoa if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovery); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index bcc98409f3f..60a617f2384 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -1789,7 +1789,7 @@ namespace CondenserLoopTowers { void CoolingTower::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("CoolingTower::initEachEnvironment"); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2481,12 +2481,12 @@ namespace CondenserLoopTowers { if (this->PerformanceInputMethod_Num == PIM::UFactor && (!this->HighSpeedTowerUAWasAutoSized)) { if (PltSizCondNum > 0) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2498,12 +2498,12 @@ namespace CondenserLoopTowers { Real64 AssumedDeltaT = DesTowerWaterDeltaT; Real64 AssumedExitTemp = DesTowerExitWaterTemp; - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AssumedExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AssumedExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2592,12 +2592,12 @@ namespace CondenserLoopTowers { } else { if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2692,12 +2692,12 @@ namespace CondenserLoopTowers { if (this->HighSpeedTowerUAWasAutoSized) { if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2791,12 +2791,12 @@ namespace CondenserLoopTowers { } else { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2911,12 +2911,12 @@ namespace CondenserLoopTowers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of delivered cooling but now is // a user input - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3094,12 +3094,12 @@ namespace CondenserLoopTowers { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of evap cooling but now is a // user input - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3193,12 +3193,12 @@ namespace CondenserLoopTowers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->TowerFreeConvNomCap > 0.0) { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of evap cooling but now user // input - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3342,12 +3342,12 @@ namespace CondenserLoopTowers { state.dataCondenserLoopTowers->towers(this->VSTower).MaxWaterFlowRatio)); } - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, (this->DesignInletWB + this->DesignApproach + this->DesignRange), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, (this->DesignInletWB + this->DesignApproach + this->DesignRange), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3589,12 +3589,12 @@ namespace CondenserLoopTowers { if (PltSizCondNum > 0) { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3607,12 +3607,12 @@ namespace CondenserLoopTowers { } else { // PltSizCondNum = 0 if (!this->TowerInletCondsAutoSize) { // can use design data entered into tower object if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3870,21 +3870,21 @@ namespace CondenserLoopTowers { // now calcuate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { if (PltSizCondNum > 0) { // user has a plant sizing object - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); this->WaterTemp = DesTowerInletWaterTemp; } else { // probably no plant sizing object - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); this->WaterTemp = DesTowerInletWaterTemp; // 35.0; // design condition } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4033,12 +4033,12 @@ namespace CondenserLoopTowers { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4085,12 +4085,12 @@ namespace CondenserLoopTowers { } else { if (!this->TowerInletCondsAutoSize) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4207,12 +4207,12 @@ namespace CondenserLoopTowers { } // now calcuate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4322,12 +4322,12 @@ namespace CondenserLoopTowers { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4405,12 +4405,12 @@ namespace CondenserLoopTowers { } else { // UA and Air flow rate given, so find Nominal Cap from running model - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4837,7 +4837,7 @@ namespace CondenserLoopTowers { // output the fraction of the time step the fan is ON this->FanCyclingRatio = FanModeFrac; // Should this be water inlet node num????? - Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5080,7 +5080,7 @@ namespace CondenserLoopTowers { this->FanCyclingRatio = FanModeFrac; this->SpeedSelected = SpeedSel; - Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5227,7 +5227,7 @@ namespace CondenserLoopTowers { while (IncrNumCellFlag) { IncrNumCellFlag = false; // Initialize inlet node water properties - Real64 const WaterDensity = FluidProperties::GetDensityGlycol(state, + Real64 const WaterDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5361,7 +5361,7 @@ namespace CondenserLoopTowers { } // IF(OutletWaterTempOFF .GT. TempSetPoint)THEN } // IF(OutletWaterTempON .LT. TempSetPoint) ie if tower should not run at full capacity - Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5449,7 +5449,7 @@ namespace CondenserLoopTowers { Real64 constexpr Acc(1.e-3); // Accuracy of solver result static constexpr std::string_view RoutineName("calculateMerkelVariableSpeedTower"); - Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5731,7 +5731,7 @@ namespace CondenserLoopTowers { Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, this->AirPress, InletAirTemp, this->AirHumRat); // Density of air [kg/m3] Real64 AirMassFlowRate = AirFlowRate * AirDensity; // Mass flow rate of air [kg/s] Real64 CpAir = Psychrometrics::PsyCpAirFnW(this->AirHumRat); // Heat capacity of air [J/kg/K] - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->WaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -6252,7 +6252,7 @@ namespace CondenserLoopTowers { Real64 const TairAvg = (this->AirTemp + OutletAirTSat) / 2.0; // Amount of water evaporated, get density water at air temp or 4 C if too cold - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, max(TairAvg, 4.0), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -6265,7 +6265,7 @@ namespace CondenserLoopTowers { } } else if (this->EvapLossMode == EvapLoss::UserFactor) { - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index 03b30e7bfbb..2931bffce2d 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -117,7 +117,7 @@ EnergyPlusData::EnergyPlusData() this->dataFans = std::make_unique(); this->dataFaultsMgr = std::make_unique(); this->dataFluidCoolers = std::make_unique(); - this->dataFluidProps = std::make_unique(); + this->dataFluid = std::make_unique(); this->dataFourPipeBeam = std::make_unique(); this->dataFuelCellElectGen = std::make_unique(); this->dataFurnaces = std::make_unique(); @@ -372,7 +372,7 @@ void EnergyPlusData::clear_state() this->dataFans->clear_state(); this->dataFaultsMgr->clear_state(); this->dataFluidCoolers->clear_state(); - this->dataFluidProps->clear_state(); + this->dataFluid->clear_state(); this->dataFourPipeBeam->clear_state(); this->dataFuelCellElectGen->clear_state(); this->dataFurnaces->clear_state(); @@ -574,7 +574,7 @@ void EnergyPlusData::init_state(EnergyPlusData &state) // do this in "topological" order meaning the first to go are the // objects that do not reference any other objects, like fluids, // schedules, curves, etc. - this->dataFluidProps->init_state(state); + this->dataFluid->init_state(state); this->dataAirLoop->init_state(state); this->dataAirLoopHVACDOAS->init_state(state); diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index b1b4f3eeb3d..95a4ea8da82 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -134,7 +134,7 @@ struct FanCoilUnitsData; struct FansData; struct FaultsManagerData; struct FluidCoolersData; -struct FluidPropertiesData; +struct FluidData; struct FourPipeBeamData; struct FuelCellElectricGeneratorData; struct FurnacesData; @@ -390,7 +390,7 @@ struct EnergyPlusData : BaseGlobalStruct std::unique_ptr dataFans; std::unique_ptr dataFaultsMgr; std::unique_ptr dataFluidCoolers; - std::unique_ptr dataFluidProps; + std::unique_ptr dataFluid; std::unique_ptr dataFourPipeBeam; std::unique_ptr dataFuelCellElectGen; std::unique_ptr dataFurnaces; diff --git a/src/EnergyPlus/DaylightingDevices.cc b/src/EnergyPlus/DaylightingDevices.cc index 37a8942ad32..b8fecc5ce33 100644 --- a/src/EnergyPlus/DaylightingDevices.cc +++ b/src/EnergyPlus/DaylightingDevices.cc @@ -1400,7 +1400,7 @@ namespace Dayltg { // REFERENCES: na // Using/Aliasing - using FluidProperties::FindArrayIndex; // USEd code could be copied here to eliminate dependence on FluidProperties + using Fluid::FindArrayIndex; // USEd code could be copied here to eliminate dependence on FluidProperties // Return value Real64 InterpolatePipeTransBeam; diff --git a/src/EnergyPlus/DesiccantDehumidifiers.cc b/src/EnergyPlus/DesiccantDehumidifiers.cc index a9a3aafc4e0..d567be8fcee 100644 --- a/src/EnergyPlus/DesiccantDehumidifiers.cc +++ b/src/EnergyPlus/DesiccantDehumidifiers.cc @@ -475,7 +475,7 @@ namespace DesiccantDehumidifiers { if (desicDehum.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); desicDehum.MaxCoilFluidFlow *= SteamDensity; } @@ -984,7 +984,7 @@ namespace DesiccantDehumidifiers { desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, errFlag); if (desicDehum.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( + Real64 SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); desicDehum.MaxCoilFluidFlow *= SteamDensity; } @@ -1654,7 +1654,7 @@ namespace DesiccantDehumidifiers { desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", desicDehum.RegenCoilName, ErrorFlag); if (desicDehum.MaxCoilFluidFlow > 0.0) { - Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 FluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidIndex, @@ -1684,7 +1684,7 @@ namespace DesiccantDehumidifiers { if (desicDehum.MaxCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); desicDehum.MaxCoilFluidFlow *= FluidDensity; } } @@ -1770,7 +1770,7 @@ namespace DesiccantDehumidifiers { //} if (CoilMaxVolFlowRate != DataSizing::AutoSize) { Real64 FluidDensity = - FluidProperties::GetDensityGlycol(state, + Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidIndex, @@ -1793,7 +1793,7 @@ namespace DesiccantDehumidifiers { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 FluidDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); desicDehum.MaxCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } } diff --git a/src/EnergyPlus/EvaporativeFluidCoolers.cc b/src/EnergyPlus/EvaporativeFluidCoolers.cc index 3e170a3c51e..d9841a04e1c 100644 --- a/src/EnergyPlus/EvaporativeFluidCoolers.cc +++ b/src/EnergyPlus/EvaporativeFluidCoolers.cc @@ -1277,7 +1277,7 @@ namespace EvaporativeFluidCoolers { // Begin environment initializations if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1406,12 +1406,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UFactor && !this->HighSpeedEvapFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1481,12 +1481,12 @@ namespace EvaporativeFluidCoolers { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) this->HighSpeedFanPower = tmpHighSpeedFanPower; } else if (PltSizCondNum > 0) { if (state.dataSize->PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1586,12 +1586,12 @@ namespace EvaporativeFluidCoolers { "must be > 25.6 C if autosizing the Evaporative Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1714,12 +1714,12 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { // Standard Design Capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now a user input with 1.25 default - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 35.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1792,12 +1792,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1952,12 +1952,12 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedStandardDesignCapacity > 0.0) { // Standard design capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now user input with default 1.25 - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2014,12 +2014,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity && this->Type == DataPlant::PlantEquipmentType::EvapFluidCooler_TwoSpd) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedUserSpecifiedDesignCapacity > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2279,7 +2279,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num????? - CpWater = FluidProperties::GetSpecificHeatGlycol(state, + CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2404,7 +2404,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num?? - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2457,7 +2457,7 @@ namespace EvaporativeFluidCoolers { Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, this->inletConds.AirPress, InletAirTemp, this->inletConds.AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(this->inletConds.AirHumRat); - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2556,7 +2556,7 @@ namespace EvaporativeFluidCoolers { Real64 TairAvg = (this->inletConds.AirTemp + OutletAirTSat) / 2.0; // Amount of water evaporated - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TairAvg, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2568,7 +2568,7 @@ namespace EvaporativeFluidCoolers { } } else if (this->EvapLossMode == EvapLoss::ByUserFactor) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2762,7 +2762,7 @@ namespace EvaporativeFluidCoolers { this->setupOutputVars(state); this->FluidIndex = state.dataPlnt->PlantLoop(state.dataSize->CurLoopNum).FluidIndex; - std::string FluidName = FluidProperties::GetGlycolNameByIndex(state, this->FluidIndex); + std::string FluidName = Fluid::GetGlycolNameByIndex(state, this->FluidIndex); if (Util::SameString(this->PerformanceInputMethod, "STANDARDDESIGNCAPACITY")) { this->PerformanceInputMethod_Num = PIM::StandardDesignCapacity; diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc index 2b9680775cc..d1fa183f8f1 100644 --- a/src/EnergyPlus/FanCoilUnits.cc +++ b/src/EnergyPlus/FanCoilUnits.cc @@ -1083,7 +1083,7 @@ namespace FanCoilUnits { fanCoil.OutAirMassFlow = RhoAir * fanCoil.OutAirVolFlow; if (fanCoil.HCoilType_Num == HCoil::Water) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, @@ -1092,7 +1092,7 @@ namespace FanCoilUnits { fanCoil.MinHotWaterFlow = rho * fanCoil.MinHotWaterVolFlow; } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, @@ -1630,12 +1630,12 @@ namespace FanCoilUnits { } fanCoil.DesHeatingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, RoutineNameNoSpace); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, @@ -1815,12 +1815,12 @@ namespace FanCoilUnits { } fanCoil.DesCoolingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, RoutineNameNoSpace); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index 9f8b613ddef..ca88e72f098 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -851,7 +851,7 @@ void FluidCoolerspecs::oneTimeInit_new(EnergyPlusData &state) void FluidCoolerspecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("FluidCoolerspecs::initEachEnvironment"); - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1008,12 +1008,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::U_FACTOR && this->HighSpeedFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1054,12 +1054,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "Setpoint must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1143,12 +1143,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "Setpoint must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1225,12 +1225,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1339,12 +1339,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::NOMINAL_CAPACITY) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1523,12 +1523,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) } if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->FluidCoolerLowSpeedNomCap > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1759,7 +1759,7 @@ void FluidCoolerspecs::calcSingleSpeed(EnergyPlusData &state) // Setpoint was not met, fluid cooler ran at full capacity this->FanPower = FanPowerOn; } - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1885,7 +1885,7 @@ void FluidCoolerspecs::calcTwoSpeed(EnergyPlusData &state) this->FanPower = FanPowerHigh; } } - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1928,7 +1928,7 @@ void CalcFluidCoolerOutlet( state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).AirHumRat); - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol( + Real64 CpWater = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).plantLoc.loopNum).FluidName, _InletWaterTemp, diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index c4353b32718..3d2b82acb64 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -64,7 +64,7 @@ namespace EnergyPlus { -namespace FluidProperties { +namespace Fluid { // MODULE INFORMATION: // AUTHOR Mike Turner @@ -686,10 +686,10 @@ namespace FluidProperties { ++FluidNum; FluidNames(FluidNum).Name = Alphas(1); if (Util::SameString(Alphas(2), Refrig)) { - ++state.dataFluidProps->NumOfRefrigerants; + ++state.dataFluid->NumOfRefrigerants; FluidNames(FluidNum).IsGlycol = false; } else if (Util::SameString(Alphas(2), Glycol)) { - ++state.dataFluidProps->NumOfGlycols; + ++state.dataFluid->NumOfGlycols; FluidNames(FluidNum).IsGlycol = true; } else { ShowSevereError(state, format("{}{}=\"{}\", invalid type", RoutineName, CurrentModuleObject, Alphas(1))); @@ -702,75 +702,75 @@ namespace FluidProperties { ShowFatalError(state, format("{} Previous errors in input cause program termination.", RoutineName)); } - if (state.dataFluidProps->NumOfRefrigerants + 1 > 0) { - state.dataFluidProps->RefrigData.allocate(state.dataFluidProps->NumOfRefrigerants + 1); - state.dataFluidProps->RefrigUsed.allocate(state.dataFluidProps->NumOfRefrigerants + 1); - state.dataFluidProps->RefrigUsed = false; - state.dataFluidProps->RefrigErrorTracking.allocate(state.dataFluidProps->NumOfRefrigerants + 1); + if (state.dataFluid->NumOfRefrigerants + 1 > 0) { + state.dataFluid->RefrigData.allocate(state.dataFluid->NumOfRefrigerants + 1); + state.dataFluid->RefrigUsed.allocate(state.dataFluid->NumOfRefrigerants + 1); + state.dataFluid->RefrigUsed = false; + state.dataFluid->RefrigErrorTracking.allocate(state.dataFluid->NumOfRefrigerants + 1); } - if (state.dataFluidProps->NumOfGlycols > 0) { - state.dataFluidProps->GlyRawData.allocate(state.dataFluidProps->NumOfGlycols); + if (state.dataFluid->NumOfGlycols > 0) { + state.dataFluid->GlyRawData.allocate(state.dataFluid->NumOfGlycols); } // Take the fluid names and assign them to the appropriate derived type - state.dataFluidProps->NumOfRefrigerants = 1; - state.dataFluidProps->NumOfGlycols = 0; - state.dataFluidProps->RefrigData(1).Name = "STEAM"; - state.dataFluidProps->RefrigUsed(1) = true; - state.dataFluidProps->RefrigErrorTracking(1).Name = "STEAM"; + state.dataFluid->NumOfRefrigerants = 1; + state.dataFluid->NumOfGlycols = 0; + state.dataFluid->RefrigData(1).Name = "STEAM"; + state.dataFluid->RefrigUsed(1) = true; + state.dataFluid->RefrigErrorTracking(1).Name = "STEAM"; for (int Loop = 1; Loop <= FluidNum; ++Loop) { if (!FluidNames(Loop).IsGlycol) { - ++state.dataFluidProps->NumOfRefrigerants; - state.dataFluidProps->RefrigData(state.dataFluidProps->NumOfRefrigerants).Name = FluidNames(Loop).Name; - state.dataFluidProps->RefrigErrorTracking(state.dataFluidProps->NumOfRefrigerants).Name = FluidNames(Loop).Name; + ++state.dataFluid->NumOfRefrigerants; + state.dataFluid->RefrigData(state.dataFluid->NumOfRefrigerants).Name = FluidNames(Loop).Name; + state.dataFluid->RefrigErrorTracking(state.dataFluid->NumOfRefrigerants).Name = FluidNames(Loop).Name; } else if (FluidNames(Loop).IsGlycol) { - ++state.dataFluidProps->NumOfGlycols; - state.dataFluidProps->GlyRawData(state.dataFluidProps->NumOfGlycols).Name = FluidNames(Loop).Name; + ++state.dataFluid->NumOfGlycols; + state.dataFluid->GlyRawData(state.dataFluid->NumOfGlycols).Name = FluidNames(Loop).Name; } } FluidNames.deallocate(); - state.dataFluidProps->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumHPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); - - state.dataFluidProps->RefrigData(1).PsTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).PsValues = DefaultSteamPressData; - state.dataFluidProps->RefrigData(1).HTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; - state.dataFluidProps->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; - state.dataFluidProps->RefrigData(1).CpTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).CpfValues = DefaultSteamCpFluidData; - state.dataFluidProps->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; - state.dataFluidProps->RefrigData(1).RhoTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; - state.dataFluidProps->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; - - state.dataFluidProps->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; - state.dataFluidProps->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; - state.dataFluidProps->RefrigData(1).SHTemps.allocate(state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).SHPress.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts); - state.dataFluidProps->RefrigData(1).HshValues.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts, - state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).RhoshValues.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts, - state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; - state.dataFluidProps->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; - state.dataFluidProps->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; - state.dataFluidProps->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; + state.dataFluid->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; + state.dataFluid->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).NumHPoints = DefaultNumSteamTemps; + state.dataFluid->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; + state.dataFluid->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; + state.dataFluid->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); + state.dataFluid->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); + + state.dataFluid->RefrigData(1).PsTemps = DefaultSteamTemps; + state.dataFluid->RefrigData(1).PsValues = DefaultSteamPressData; + state.dataFluid->RefrigData(1).HTemps = DefaultSteamTemps; + state.dataFluid->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; + state.dataFluid->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; + state.dataFluid->RefrigData(1).CpTemps = DefaultSteamTemps; + state.dataFluid->RefrigData(1).CpfValues = DefaultSteamCpFluidData; + state.dataFluid->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; + state.dataFluid->RefrigData(1).RhoTemps = DefaultSteamTemps; + state.dataFluid->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; + state.dataFluid->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; + + state.dataFluid->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; + state.dataFluid->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; + state.dataFluid->RefrigData(1).SHTemps.allocate(state.dataFluid->RefrigData(1).NumSuperTempPts); + state.dataFluid->RefrigData(1).SHPress.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts); + state.dataFluid->RefrigData(1).HshValues.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts, + state.dataFluid->RefrigData(1).NumSuperTempPts); + state.dataFluid->RefrigData(1).RhoshValues.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts, + state.dataFluid->RefrigData(1).NumSuperTempPts); + state.dataFluid->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; + state.dataFluid->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; + state.dataFluid->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; + state.dataFluid->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; // Read in all of the temperature arrays in the input file FluidTemps.allocate(NumOfFluidTempArrays); @@ -819,7 +819,7 @@ namespace FluidProperties { // Go through each refrigerant found in the fluid names statement and read in the data // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. - for (int Loop = 2; Loop <= state.dataFluidProps->NumOfRefrigerants; ++Loop) { + for (int Loop = 2; Loop <= state.dataFluid->NumOfRefrigerants; ++Loop) { // For each property, cycle through all the valid input until the proper match is found. @@ -844,7 +844,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -853,14 +853,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).PsTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumPsPoints); - state.dataFluidProps->RefrigData(Loop).PsValues.allocate(state.dataFluidProps->RefrigData(Loop).NumPsPoints); + state.dataFluid->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->RefrigData(Loop).PsTemps.allocate(state.dataFluid->RefrigData(Loop).NumPsPoints); + state.dataFluid->RefrigData(Loop).PsValues.allocate(state.dataFluid->RefrigData(Loop).NumPsPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumPsPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumPsPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " "same number of points", @@ -868,15 +868,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # pressure points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumPsPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumPsPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -884,7 +884,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid gas/fluid pressure input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -898,7 +898,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, // then no sat press data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", cAlphaFieldNames(2), @@ -926,7 +926,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -935,14 +935,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).HTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); - state.dataFluidProps->RefrigData(Loop).HfValues.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); + state.dataFluid->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->RefrigData(Loop).HTemps.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); + state.dataFluid->RefrigData(Loop).HfValues.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumHPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowSevereError(state, format("Temperature Name={}, Temperature array and saturated fluid enthalpy array must have the same " "number of points", @@ -950,15 +950,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumHPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -966,7 +966,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -979,7 +979,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1006,7 +1006,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1014,7 +1014,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for enthalpy fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1022,12 +1022,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).HfgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); + state.dataFluid->RefrigData(Loop).HfgValues.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumHPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid enthalpy array must have " "the same number of points", @@ -1035,14 +1035,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumHPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1050,7 +1050,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1063,7 +1063,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="FluidGas".)", @@ -1092,7 +1092,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1101,14 +1101,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).CpTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); - state.dataFluidProps->RefrigData(Loop).CpfValues.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); + state.dataFluid->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->RefrigData(Loop).CpTemps.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); + state.dataFluid->RefrigData(Loop).CpfValues.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowSevereError( state, format("Temperature Name={}, Temperature array and saturated fluid Cp array must have the same number of points", @@ -1116,15 +1116,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumCpPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1132,7 +1132,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1145,7 +1145,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Fluid Specific Heat found. Need properties to be entered with {}="SpecificHeat" and {}="Fluid".)", @@ -1173,7 +1173,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1181,7 +1181,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for specific heat fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1189,12 +1189,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).CpfgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); + state.dataFluid->RefrigData(Loop).CpfgValues.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1203,14 +1203,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumCpPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1218,7 +1218,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1231,7 +1231,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1261,7 +1261,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1270,14 +1270,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).RhoTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); - state.dataFluidProps->RefrigData(Loop).RhofValues.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); + state.dataFluid->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->RefrigData(Loop).RhoTemps.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); + state.dataFluid->RefrigData(Loop).RhofValues.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated fluid density array must have the " "same number of points", @@ -1285,15 +1285,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Density points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumRhoPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1301,7 +1301,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1314,7 +1314,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Density found. Need properties to be entered with {}="Density" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1341,7 +1341,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1349,7 +1349,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for density fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1357,12 +1357,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).RhofgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); + state.dataFluid->RefrigData(Loop).RhofgValues.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != state.dataFluid->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid density array must have the " "same number of points", @@ -1370,14 +1370,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # density points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumRhoPoints)); + state.dataFluid->RefrigData(Loop).Name, + state.dataFluid->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); + state.dataFluid->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1385,7 +1385,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1398,7 +1398,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowSevereError( state, format(R"(No Saturated Gas/Fluid Density found. Need properties to be entered with {}="Density" and {}="FluidGas".)", @@ -1454,7 +1454,7 @@ namespace FluidProperties { !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}", "{}".)", Enthalpy, SpecificHeat, Density)); @@ -1469,7 +1469,7 @@ namespace FluidProperties { !Util::SameString(Alphas(2), SpecificHeat) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, @@ -1481,7 +1481,7 @@ namespace FluidProperties { } else { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(3), Alphas(3))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Fluid, GasFluid)); ShowContinueError(state, @@ -1518,7 +1518,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1526,7 +1526,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1535,7 +1535,7 @@ namespace FluidProperties { } } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "No pressure data found for superheated enthalpy"); ErrorsFound = true; } @@ -1544,13 +1544,13 @@ namespace FluidProperties { // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).SHTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); - state.dataFluidProps->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->RefrigData(Loop).SHTemps.allocate(state.dataFluid->RefrigData(Loop).NumSuperTempPts); + state.dataFluid->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with superheated enthalpy data"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1558,10 +1558,10 @@ namespace FluidProperties { } // Next, allocate the pressure related arrays - state.dataFluidProps->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; - state.dataFluidProps->RefrigData(Loop).SHPress.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts); - state.dataFluidProps->RefrigData(Loop).HshValues.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts, - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); + state.dataFluid->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; + state.dataFluid->RefrigData(Loop).SHPress.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts); + state.dataFluid->RefrigData(Loop).HshValues.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts, + state.dataFluid->RefrigData(Loop).NumSuperTempPts); // Finally, get the pressure and enthalpy values from the user input CurrentModuleObject = "FluidProperties:Superheated"; @@ -1581,10 +1581,10 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1622,27 +1622,27 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - state.dataFluidProps->RefrigData(Loop).SHPress(InData) = Numbers(1); + state.dataFluid->RefrigData(Loop).SHPress(InData) = Numbers(1); // a little error trapping if (InData > 1) { - if (state.dataFluidProps->RefrigData(Loop).SHPress(InData) <= state.dataFluidProps->RefrigData(Loop).SHPress(InData - 1)) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (state.dataFluid->RefrigData(Loop).SHPress(InData) <= state.dataFluid->RefrigData(Loop).SHPress(InData - 1)) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Pressures must be entered in ascending order for fluid property data"); ShowContinueError(state, format("First Occurrence at Pressure({}) {{{:.3R}}} >= Pressure({}) {{{:.3R}}}", InData - 1, - state.dataFluidProps->RefrigData(Loop).SHPress(InData - 1), + state.dataFluid->RefrigData(Loop).SHPress(InData - 1), InData, - state.dataFluidProps->RefrigData(Loop).SHPress(InData))); + state.dataFluid->RefrigData(Loop).SHPress(InData))); ErrorsFound = true; break; } } - if ((NumNumbers - 1) == state.dataFluidProps->RefrigData(Loop).NumSuperTempPts) { - state.dataFluidProps->RefrigData(Loop).HshValues(InData, {1, state.dataFluidProps->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == state.dataFluid->RefrigData(Loop).NumSuperTempPts) { + state.dataFluid->RefrigData(Loop).HshValues(InData, {1, state.dataFluid->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated enthalpy data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1654,8 +1654,8 @@ namespace FluidProperties { // First find the number of pressure value syntax lines have been entered and // make sure that all of the pressure input is linked to the same temperature list // Then allocate the arrays and read the data into the proper place - state.dataFluidProps->RefrigData(Loop).RhoshValues.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts, - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); + state.dataFluid->RefrigData(Loop).RhoshValues.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts, + state.dataFluid->RefrigData(Loop).NumSuperTempPts); CurrentModuleObject = "FluidProperties:Superheated"; NumOfPressPts = 0; PressurePtr.allocate(NumOfSHFluidPropArrays); @@ -1672,10 +1672,10 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1713,21 +1713,21 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if (std::abs(Numbers(1) - state.dataFluidProps->RefrigData(Loop).SHPress(InData)) > PressToler) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (std::abs(Numbers(1) - state.dataFluid->RefrigData(Loop).SHPress(InData)) > PressToler) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same refrigerant must use the same pressure data"); ErrorsFound = true; } if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ErrorsFound = true; } - if ((NumNumbers - 1) == state.dataFluidProps->RefrigData(Loop).NumSuperTempPts) { - state.dataFluidProps->RefrigData(Loop).RhoshValues(InData, {1, state.dataFluidProps->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == state.dataFluid->RefrigData(Loop).NumSuperTempPts) { + state.dataFluid->RefrigData(Loop).RhoshValues(InData, {1, state.dataFluid->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1755,7 +1755,7 @@ namespace FluidProperties { if (!Util::SameString(Alphas(2), Enthalpy) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Enthalpy, Density)); ShowContinueError(state, format("Pressure value of this item=[{:.2R}].", Numbers(1))); @@ -1770,12 +1770,12 @@ namespace FluidProperties { } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowSevereError(state, "No pressure data found for superheated density"); ErrorsFound = true; } - if (NumOfPressPts != state.dataFluidProps->RefrigData(Loop).NumSuperPressPts) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (NumOfPressPts != state.dataFluid->RefrigData(Loop).NumSuperPressPts) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); ShowSevereError(state, "Number of pressure points for superheated data different for enthalpy and density"); ErrorsFound = true; } @@ -1787,7 +1787,7 @@ namespace FluidProperties { // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. CurrentModuleObject = "FluidProperties:Concentration"; - for (int Loop = 1; Loop <= state.dataFluidProps->NumOfGlycols; ++Loop) { + for (int Loop = 1; Loop <= state.dataFluid->NumOfGlycols; ++Loop) { // Get: ***** SPECIFIC HEAT of GLYCOLS ***** // First find the number of concentration value syntax lines have been entered and @@ -1795,7 +1795,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; int NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).CpDataPresent = false; + state.dataFluid->GlyRawData(Loop).CpDataPresent = false; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, @@ -1809,7 +1809,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1817,7 +1817,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol specific heat data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1828,26 +1828,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).CpDataPresent = true; + state.dataFluid->GlyRawData(Loop).CpDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).CpTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpTempPts); - state.dataFluidProps->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->GlyRawData(Loop).CpTemps.allocate(state.dataFluid->GlyRawData(Loop).NumCpTempPts); + state.dataFluid->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the specific heat related arrays - state.dataFluidProps->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CpConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpConcPts); - state.dataFluidProps->GlyRawData(Loop).CpValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpConcPts, - state.dataFluidProps->GlyRawData(Loop).NumCpTempPts); + state.dataFluid->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; + state.dataFluid->GlyRawData(Loop).CpConcs.allocate(state.dataFluid->GlyRawData(Loop).NumCpConcPts); + state.dataFluid->GlyRawData(Loop).CpValues.allocate(state.dataFluid->GlyRawData(Loop).NumCpConcPts, + state.dataFluid->GlyRawData(Loop).NumCpTempPts); // Finally, get the specific heat and concentration values from the user input CurrentModuleObject = "FluidProperties:Concentration"; @@ -1865,32 +1865,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); + state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { + if (state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { + if (state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) <= + state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumCpTempPts) { - state.dataFluidProps->GlyRawData(Loop).CpValues(NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumCpTempPts}) = + if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumCpTempPts) { + state.dataFluid->GlyRawData(Loop).CpValues(NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumCpTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of specific heat data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1903,7 +1903,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).RhoDataPresent = false; + state.dataFluid->GlyRawData(Loop).RhoDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for density are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1918,7 +1918,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1926,7 +1926,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol density data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1937,26 +1937,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).RhoDataPresent = true; + state.dataFluid->GlyRawData(Loop).RhoDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).RhoTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts); - state.dataFluidProps->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->GlyRawData(Loop).RhoTemps.allocate(state.dataFluid->GlyRawData(Loop).NumRhoTempPts); + state.dataFluid->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the density related arrays - state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).RhoConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts); - state.dataFluidProps->GlyRawData(Loop).RhoValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts, - state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts); + state.dataFluid->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; + state.dataFluid->GlyRawData(Loop).RhoConcs.allocate(state.dataFluid->GlyRawData(Loop).NumRhoConcPts); + state.dataFluid->GlyRawData(Loop).RhoValues.allocate(state.dataFluid->GlyRawData(Loop).NumRhoConcPts, + state.dataFluid->GlyRawData(Loop).NumRhoTempPts); // Finally, get the density and concentration values from the user input NumOfConcPts = 0; @@ -1974,32 +1974,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); + state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { + if (state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { + if (state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= + state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts) { - state.dataFluidProps->GlyRawData(Loop).RhoValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumRhoTempPts) { + state.dataFluid->GlyRawData(Loop).RhoValues( + NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2012,7 +2012,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).CondDataPresent = false; + state.dataFluid->GlyRawData(Loop).CondDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for conductivity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2027,7 +2027,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2035,7 +2035,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol conductivity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2046,26 +2046,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).CondDataPresent = true; + state.dataFluid->GlyRawData(Loop).CondDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).CondTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondTempPts); - state.dataFluidProps->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->GlyRawData(Loop).CondTemps.allocate(state.dataFluid->GlyRawData(Loop).NumCondTempPts); + state.dataFluid->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the conductivity related arrays - state.dataFluidProps->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CondConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondConcPts); - state.dataFluidProps->GlyRawData(Loop).CondValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondConcPts, - state.dataFluidProps->GlyRawData(Loop).NumCondTempPts); + state.dataFluid->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; + state.dataFluid->GlyRawData(Loop).CondConcs.allocate(state.dataFluid->GlyRawData(Loop).NumCondConcPts); + state.dataFluid->GlyRawData(Loop).CondValues.allocate(state.dataFluid->GlyRawData(Loop).NumCondConcPts, + state.dataFluid->GlyRawData(Loop).NumCondTempPts); // Finally, get the conductivity and concentration values from the user input NumOfConcPts = 0; @@ -2083,32 +2083,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); + state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { + if (state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { + if (state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) <= + state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumCondTempPts) { - state.dataFluidProps->GlyRawData(Loop).CondValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumCondTempPts) { + state.dataFluid->GlyRawData(Loop).CondValues( + NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of conductivity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2121,7 +2121,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).ViscDataPresent = false; + state.dataFluid->GlyRawData(Loop).ViscDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for viscosity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2136,7 +2136,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2144,7 +2144,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol viscosity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2153,28 +2153,28 @@ namespace FluidProperties { } } if (NumOfConcPts > 0) { - state.dataFluidProps->GlyRawData(Loop).ViscDataPresent = true; + state.dataFluid->GlyRawData(Loop).ViscDataPresent = true; // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).ViscTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscTempPts); - state.dataFluidProps->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; + state.dataFluid->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluid->GlyRawData(Loop).ViscTemps.allocate(state.dataFluid->GlyRawData(Loop).NumViscTempPts); + state.dataFluid->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the viscosity related arrays - state.dataFluidProps->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).ViscConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscConcPts); - state.dataFluidProps->GlyRawData(Loop).ViscValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscConcPts, - state.dataFluidProps->GlyRawData(Loop).NumViscTempPts); + state.dataFluid->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; + state.dataFluid->GlyRawData(Loop).ViscConcs.allocate(state.dataFluid->GlyRawData(Loop).NumViscConcPts); + state.dataFluid->GlyRawData(Loop).ViscValues.allocate(state.dataFluid->GlyRawData(Loop).NumViscConcPts, + state.dataFluid->GlyRawData(Loop).NumViscTempPts); // Finally, get the viscosity and concentration values from the user input NumOfConcPts = 0; @@ -2192,32 +2192,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); + state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { + if (state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { + if (state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= + state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumViscTempPts) { - state.dataFluidProps->GlyRawData(Loop).ViscValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumViscTempPts) { + state.dataFluid->GlyRawData(Loop).ViscValues( + NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of viscosity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2258,40 +2258,40 @@ namespace FluidProperties { NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); int NumOfGlyConcs = NumOfOptionalInput + 1; - state.dataFluidProps->GlycolData.allocate(NumOfGlyConcs); - state.dataFluidProps->GlycolUsed.dimension(NumOfGlyConcs, false); + state.dataFluid->GlycolData.allocate(NumOfGlyConcs); + state.dataFluid->GlycolUsed.dimension(NumOfGlyConcs, false); - state.dataFluidProps->GlycolUsed(1) = true; // mark Water as always used + state.dataFluid->GlycolUsed(1) = true; // mark Water as always used // First "glycol" is always pure water. Load data from default arrays - state.dataFluidProps->GlycolData(1).Name = "WATER"; - state.dataFluidProps->GlycolData(1).GlycolName = "WATER"; - state.dataFluidProps->GlycolData(1).GlycolIndex = 0; - state.dataFluidProps->GlycolData(1).Concentration = 1.0; - state.dataFluidProps->GlycolData(1).CpDataPresent = true; - state.dataFluidProps->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).RhoDataPresent = true; - state.dataFluidProps->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).CondDataPresent = true; - state.dataFluidProps->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).ViscDataPresent = true; - state.dataFluidProps->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).CpTemps.allocate(state.dataFluidProps->GlycolData(1).NumCpTempPts); - state.dataFluidProps->GlycolData(1).CpValues.allocate(state.dataFluidProps->GlycolData(1).NumCpTempPts); - state.dataFluidProps->GlycolData(1).RhoTemps.allocate(state.dataFluidProps->GlycolData(1).NumRhoTempPts); - state.dataFluidProps->GlycolData(1).RhoValues.allocate(state.dataFluidProps->GlycolData(1).NumRhoTempPts); - state.dataFluidProps->GlycolData(1).CondTemps.allocate(state.dataFluidProps->GlycolData(1).NumCondTempPts); - state.dataFluidProps->GlycolData(1).CondValues.allocate(state.dataFluidProps->GlycolData(1).NumCondTempPts); - state.dataFluidProps->GlycolData(1).ViscTemps.allocate(state.dataFluidProps->GlycolData(1).NumViscTempPts); - state.dataFluidProps->GlycolData(1).ViscValues.allocate(state.dataFluidProps->GlycolData(1).NumViscTempPts); - state.dataFluidProps->GlycolData(1).CpTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).CpValues = DefaultWaterCpData; - state.dataFluidProps->GlycolData(1).RhoTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).RhoValues = DefaultWaterRhoData; - state.dataFluidProps->GlycolData(1).CondTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).CondValues = DefaultWaterCondData; - state.dataFluidProps->GlycolData(1).ViscTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).ViscValues = DefaultWaterViscData; + state.dataFluid->GlycolData(1).Name = "WATER"; + state.dataFluid->GlycolData(1).GlycolName = "WATER"; + state.dataFluid->GlycolData(1).GlycolIndex = 0; + state.dataFluid->GlycolData(1).Concentration = 1.0; + state.dataFluid->GlycolData(1).CpDataPresent = true; + state.dataFluid->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(1).RhoDataPresent = true; + state.dataFluid->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(1).CondDataPresent = true; + state.dataFluid->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(1).ViscDataPresent = true; + state.dataFluid->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(1).CpTemps.allocate(state.dataFluid->GlycolData(1).NumCpTempPts); + state.dataFluid->GlycolData(1).CpValues.allocate(state.dataFluid->GlycolData(1).NumCpTempPts); + state.dataFluid->GlycolData(1).RhoTemps.allocate(state.dataFluid->GlycolData(1).NumRhoTempPts); + state.dataFluid->GlycolData(1).RhoValues.allocate(state.dataFluid->GlycolData(1).NumRhoTempPts); + state.dataFluid->GlycolData(1).CondTemps.allocate(state.dataFluid->GlycolData(1).NumCondTempPts); + state.dataFluid->GlycolData(1).CondValues.allocate(state.dataFluid->GlycolData(1).NumCondTempPts); + state.dataFluid->GlycolData(1).ViscTemps.allocate(state.dataFluid->GlycolData(1).NumViscTempPts); + state.dataFluid->GlycolData(1).ViscValues.allocate(state.dataFluid->GlycolData(1).NumViscTempPts); + state.dataFluid->GlycolData(1).CpTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(1).CpValues = DefaultWaterCpData; + state.dataFluid->GlycolData(1).RhoTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(1).RhoValues = DefaultWaterRhoData; + state.dataFluid->GlycolData(1).CondTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(1).CondValues = DefaultWaterCondData; + state.dataFluid->GlycolData(1).ViscTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(1).ViscValues = DefaultWaterViscData; NumOfGlyConcs = 1; // Water is always available, everything else must be specified @@ -2312,24 +2312,24 @@ namespace FluidProperties { if (Util::SameString(Alphas(2), EthyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), PropyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), "UserDefinedGlycolType")) { - for (InData = 1; InData <= state.dataFluidProps->NumOfGlycols; ++InData) { - if (Util::SameString(Alphas(3), state.dataFluidProps->GlyRawData(InData).Name)) { + for (InData = 1; InData <= state.dataFluid->NumOfGlycols; ++InData) { + if (Util::SameString(Alphas(3), state.dataFluid->GlyRawData(InData).Name)) { GlycolFound = true; break; // DO LOOP through user defined glycols } } if (GlycolFound) { ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); + state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); } else { ShowSevereError(state, format("{}{}=\"{}\", invalid reference", RoutineName, CurrentModuleObject, Alphas(1))); ShowContinueError(state, format("... not found in the FluidProperties:Name list: \"{}\".", Alphas(3))); @@ -2342,192 +2342,192 @@ namespace FluidProperties { ErrorsFound = true; } if (!GlycolFound) continue; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); + state.dataFluid->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); } // Now initialize the rest of the data for the glycols for (int Loop = 2; Loop <= NumOfGlyConcs; ++Loop) { // Check to see if glycol name is one of the defaults or is listed in the Fluid Name list - if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, EthyleneGlycol)) { - state.dataFluidProps->GlycolData(Loop).GlycolIndex = EthyleneGlycolIndex; - } else if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, PropyleneGlycol)) { - state.dataFluidProps->GlycolData(Loop).GlycolIndex = PropyleneGlycolIndex; + if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, EthyleneGlycol)) { + state.dataFluid->GlycolData(Loop).GlycolIndex = EthyleneGlycolIndex; + } else if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, PropyleneGlycol)) { + state.dataFluid->GlycolData(Loop).GlycolIndex = PropyleneGlycolIndex; } else { - for (InData = 1; InData <= state.dataFluidProps->NumOfGlycols; ++InData) { - if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, state.dataFluidProps->GlyRawData(InData).Name)) { - state.dataFluidProps->GlycolData(Loop).GlycolIndex = InData; + for (InData = 1; InData <= state.dataFluid->NumOfGlycols; ++InData) { + if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, state.dataFluid->GlyRawData(InData).Name)) { + state.dataFluid->GlycolData(Loop).GlycolIndex = InData; break; // DO LOOP through user defined glycols } } } // Set the rest of the parameters... - if ((state.dataFluidProps->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) || - (state.dataFluidProps->GlycolData(Loop).GlycolIndex == PropyleneGlycolIndex)) { - - state.dataFluidProps->GlycolData(Loop).CpDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).RhoDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).CondDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).ViscDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).CpTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoValues.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).CondTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscValues.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).CpTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).RhoTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).CondTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).ViscTemps = DefaultGlycolTemps; - - if (state.dataFluidProps->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) { + if ((state.dataFluid->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) || + (state.dataFluid->GlycolData(Loop).GlycolIndex == PropyleneGlycolIndex)) { + + state.dataFluid->GlycolData(Loop).CpDataPresent = true; + state.dataFluid->GlycolData(Loop).NumCpTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(Loop).RhoDataPresent = true; + state.dataFluid->GlycolData(Loop).NumRhoTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(Loop).CondDataPresent = true; + state.dataFluid->GlycolData(Loop).NumCondTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(Loop).ViscDataPresent = true; + state.dataFluid->GlycolData(Loop).NumViscTempPts = DefaultNumGlyTemps; + state.dataFluid->GlycolData(Loop).CpTemps.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); + state.dataFluid->GlycolData(Loop).CpValues.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); + state.dataFluid->GlycolData(Loop).RhoTemps.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); + state.dataFluid->GlycolData(Loop).RhoValues.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); + state.dataFluid->GlycolData(Loop).CondTemps.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); + state.dataFluid->GlycolData(Loop).CondValues.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); + state.dataFluid->GlycolData(Loop).ViscTemps.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); + state.dataFluid->GlycolData(Loop).ViscValues.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); + state.dataFluid->GlycolData(Loop).CpTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(Loop).RhoTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(Loop).CondTemps = DefaultGlycolTemps; + state.dataFluid->GlycolData(Loop).ViscTemps = DefaultGlycolTemps; + + if (state.dataFluid->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) { InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCpData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CpValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyRhoData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCondData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyViscData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).ViscValues); } else { // == PropyleneGlycolIndex InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCpData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CpValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyRhoData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCondData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyViscData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).ViscValues); } } else { // User-defined fluid - int Index = state.dataFluidProps->GlycolData(Loop).GlycolIndex; + int Index = state.dataFluid->GlycolData(Loop).GlycolIndex; // Specific heat data: - if (state.dataFluidProps->GlyRawData(Index).CpDataPresent) { - state.dataFluidProps->GlycolData(Loop).CpDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCpTempPts = state.dataFluidProps->GlyRawData(Index).NumCpTempPts; - state.dataFluidProps->GlycolData(Loop).CpTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpTemps = state.dataFluidProps->GlyRawData(Index).CpTemps; + if (state.dataFluid->GlyRawData(Index).CpDataPresent) { + state.dataFluid->GlycolData(Loop).CpDataPresent = true; + state.dataFluid->GlycolData(Loop).NumCpTempPts = state.dataFluid->GlyRawData(Index).NumCpTempPts; + state.dataFluid->GlycolData(Loop).CpTemps.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); + state.dataFluid->GlycolData(Loop).CpValues.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); + state.dataFluid->GlycolData(Loop).CpTemps = state.dataFluid->GlyRawData(Index).CpTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumCpConcPts, - state.dataFluidProps->GlyRawData(Index).NumCpTempPts, - state.dataFluidProps->GlyRawData(Index).CpConcs, - state.dataFluidProps->GlyRawData(Index).CpValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); + state.dataFluid->GlyRawData(Index).NumCpConcPts, + state.dataFluid->GlyRawData(Index).NumCpTempPts, + state.dataFluid->GlyRawData(Index).CpConcs, + state.dataFluid->GlyRawData(Index).CpValues, + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CpValues); } else { ShowSevereError(state, format("{}Specific heat data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Density data: - if (state.dataFluidProps->GlyRawData(Index).CpDataPresent) { - state.dataFluidProps->GlycolData(Loop).RhoDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumRhoTempPts = state.dataFluidProps->GlyRawData(Index).NumRhoTempPts; - state.dataFluidProps->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoValues.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoTemps = state.dataFluidProps->GlyRawData(Index).RhoTemps; + if (state.dataFluid->GlyRawData(Index).CpDataPresent) { + state.dataFluid->GlycolData(Loop).RhoDataPresent = true; + state.dataFluid->GlycolData(Loop).NumRhoTempPts = state.dataFluid->GlyRawData(Index).NumRhoTempPts; + state.dataFluid->GlycolData(Loop).RhoTemps.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); + state.dataFluid->GlycolData(Loop).RhoValues.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); + state.dataFluid->GlycolData(Loop).RhoTemps = state.dataFluid->GlyRawData(Index).RhoTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumRhoConcPts, - state.dataFluidProps->GlyRawData(Index).NumRhoTempPts, - state.dataFluidProps->GlyRawData(Index).RhoConcs, - state.dataFluidProps->GlyRawData(Index).RhoValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + state.dataFluid->GlyRawData(Index).NumRhoConcPts, + state.dataFluid->GlyRawData(Index).NumRhoTempPts, + state.dataFluid->GlyRawData(Index).RhoConcs, + state.dataFluid->GlyRawData(Index).RhoValues, + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).RhoValues); } else { ShowSevereError(state, format("{}Density data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Conductivity data: - if (state.dataFluidProps->GlyRawData(Index).CondDataPresent) { - state.dataFluidProps->GlycolData(Loop).CondDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCondTempPts = state.dataFluidProps->GlyRawData(Index).NumCondTempPts; - state.dataFluidProps->GlycolData(Loop).CondTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondTemps = state.dataFluidProps->GlyRawData(Index).CondTemps; + if (state.dataFluid->GlyRawData(Index).CondDataPresent) { + state.dataFluid->GlycolData(Loop).CondDataPresent = true; + state.dataFluid->GlycolData(Loop).NumCondTempPts = state.dataFluid->GlyRawData(Index).NumCondTempPts; + state.dataFluid->GlycolData(Loop).CondTemps.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); + state.dataFluid->GlycolData(Loop).CondValues.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); + state.dataFluid->GlycolData(Loop).CondTemps = state.dataFluid->GlyRawData(Index).CondTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumCondConcPts, - state.dataFluidProps->GlyRawData(Index).NumCondTempPts, - state.dataFluidProps->GlyRawData(Index).CondConcs, - state.dataFluidProps->GlyRawData(Index).CondValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + state.dataFluid->GlyRawData(Index).NumCondConcPts, + state.dataFluid->GlyRawData(Index).NumCondTempPts, + state.dataFluid->GlyRawData(Index).CondConcs, + state.dataFluid->GlyRawData(Index).CondValues, + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).CondValues); } else { ShowSevereError(state, format("{}Conductivity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Viscosity data: - if (state.dataFluidProps->GlyRawData(Index).ViscDataPresent) { - state.dataFluidProps->GlycolData(Loop).ViscDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumViscTempPts = state.dataFluidProps->GlyRawData(Index).NumViscTempPts; - state.dataFluidProps->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscValues.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscTemps = state.dataFluidProps->GlyRawData(Index).ViscTemps; + if (state.dataFluid->GlyRawData(Index).ViscDataPresent) { + state.dataFluid->GlycolData(Loop).ViscDataPresent = true; + state.dataFluid->GlycolData(Loop).NumViscTempPts = state.dataFluid->GlyRawData(Index).NumViscTempPts; + state.dataFluid->GlycolData(Loop).ViscTemps.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); + state.dataFluid->GlycolData(Loop).ViscValues.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); + state.dataFluid->GlycolData(Loop).ViscTemps = state.dataFluid->GlyRawData(Index).ViscTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumViscConcPts, - state.dataFluidProps->GlyRawData(Index).NumViscTempPts, - state.dataFluidProps->GlyRawData(Index).ViscConcs, - state.dataFluidProps->GlyRawData(Index).ViscValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + state.dataFluid->GlyRawData(Index).NumViscConcPts, + state.dataFluid->GlyRawData(Index).NumViscTempPts, + state.dataFluid->GlyRawData(Index).ViscConcs, + state.dataFluid->GlyRawData(Index).ViscValues, + state.dataFluid->GlycolData(Loop).Concentration, + state.dataFluid->GlycolData(Loop).ViscValues); } else { ShowSevereError(state, format("{}Viscosity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); ErrorsFound = true; } } } - state.dataFluidProps->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number - state.dataFluidProps->GlycolErrorTracking.allocate(state.dataFluidProps->NumOfGlycols); - for (std::size_t i = 0; i < state.dataFluidProps->GlycolErrorTracking.size(); ++i) - state.dataFluidProps->GlycolErrorTracking[i].Name = state.dataFluidProps->GlycolData[i].Name; + state.dataFluid->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number + state.dataFluid->GlycolErrorTracking.allocate(state.dataFluid->NumOfGlycols); + for (std::size_t i = 0; i < state.dataFluid->GlycolErrorTracking.size(); ++i) + state.dataFluid->GlycolErrorTracking[i].Name = state.dataFluid->GlycolData[i].Name; if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols @@ -2546,16 +2546,16 @@ namespace FluidProperties { ShowFatalError(state, format("{}Previous errors in input cause program termination.", RoutineName)); } - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) state.dataFluidProps->DebugReportGlycols = true; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) state.dataFluid->DebugReportGlycols = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTREFRIGERANTS") > 0) - state.dataFluidProps->DebugReportRefrigerants = true; + state.dataFluid->DebugReportRefrigerants = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEGLYCOLERRORLIMIT") > 0) - state.dataFluidProps->GlycolErrorLimitTest += 10; + state.dataFluid->GlycolErrorLimitTest += 10; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEREFRIGERANTERRORLIMIT") > 0) - state.dataFluidProps->RefrigerantErrorLimitTest += 10; + state.dataFluid->RefrigerantErrorLimitTest += 10; - if (state.dataFluidProps->DebugReportGlycols) ReportAndTestGlycols(state); - if (state.dataFluidProps->DebugReportRefrigerants) ReportAndTestRefrigerants(state); + if (state.dataFluid->DebugReportGlycols) ReportAndTestGlycols(state); + if (state.dataFluid->DebugReportRefrigerants) ReportAndTestRefrigerants(state); } [[maybe_unused]] static constexpr std::array, DefaultNumSteamSuperheatedPressure> @@ -4683,8 +4683,8 @@ namespace FluidProperties { // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. - for (int GlycolNum = 1; GlycolNum <= state.dataFluidProps->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluidProps->GlycolData(GlycolNum); + for (int GlycolNum = 1; GlycolNum <= state.dataFluid->NumOfGlycols; ++GlycolNum) { + auto &glycol = state.dataFluid->GlycolData(GlycolNum); if (glycol.CpDataPresent) { // check for lowest non-zero value by referencing temp data for (int IndexNum = 1; IndexNum <= glycol.NumCpTempPts; ++IndexNum) { @@ -4786,8 +4786,8 @@ namespace FluidProperties { // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. - for (int RefrigNum = 1; RefrigNum <= state.dataFluidProps->NumOfRefrigerants; ++RefrigNum) { - auto &refrig = state.dataFluidProps->RefrigData(RefrigNum); + for (int RefrigNum = 1; RefrigNum <= state.dataFluid->NumOfRefrigerants; ++RefrigNum) { + auto &refrig = state.dataFluid->RefrigData(RefrigNum); for (int IndexNum = 1; IndexNum <= refrig.NumPsPoints; ++IndexNum) { if (refrig.PsValues(IndexNum) <= 0.0) continue; refrig.PsLowPresIndex = IndexNum; @@ -4926,10 +4926,10 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from glycol functions - state.dataFluidProps->GetInput = false; // input has already been gotten + state.dataFluid->GetInput = false; // input has already been gotten - for (int GlycolNum = 1; GlycolNum <= state.dataFluidProps->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluidProps->GlycolData(GlycolNum); + for (int GlycolNum = 1; GlycolNum <= state.dataFluid->NumOfGlycols; ++GlycolNum) { + auto &glycol = state.dataFluid->GlycolData(GlycolNum); int GlycolIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: if (!glycol.GlycolName.empty()) { @@ -5168,223 +5168,223 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from refrigerant functions - state.dataFluidProps->GetInput = false; // input has already been gotten + state.dataFluid->GetInput = false; // input has already been gotten - for (int RefrigNum = 1; RefrigNum <= state.dataFluidProps->NumOfRefrigerants; ++RefrigNum) { + for (int RefrigNum = 1; RefrigNum <= state.dataFluid->NumOfRefrigerants; ++RefrigNum) { int RefrigIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: - if (!state.dataFluidProps->RefrigData(RefrigNum).Name.empty()) { - print(state.files.debug, "Refrigerant={}", state.dataFluidProps->RefrigData(RefrigNum).Name); + if (!state.dataFluid->RefrigData(RefrigNum).Name.empty()) { + print(state.files.debug, "Refrigerant={}", state.dataFluid->RefrigData(RefrigNum).Name); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumPsPoints > 0) { print(state.files.debug, "Saturation Pressures Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).PsLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).PsHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).PsHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).PsLowTempValue, + state.dataFluid->RefrigData(RefrigNum).PsLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).PsHighTempValue, + state.dataFluid->RefrigData(RefrigNum).PsHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); print(state.files.debug, "Saturation Pressure:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsValues(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluid->RefrigData(RefrigNum).PsValues(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumHPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumHPoints > 0) { print(state.files.debug, "Enthalpy Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).HfHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).HfLowTempValue, + state.dataFluid->RefrigData(RefrigNum).HfLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).HfHighTempValue, + state.dataFluid->RefrigData(RefrigNum).HfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HfValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HfValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfValues(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + state.dataFluid->RefrigData(RefrigNum).HfValues(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).HfgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfgHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).HfgLowTempValue, + state.dataFluid->RefrigData(RefrigNum).HfgLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).HfgHighTempValue, + state.dataFluid->RefrigData(RefrigNum).HfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HfgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HfgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfgValues(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + state.dataFluid->RefrigData(RefrigNum).HfgValues(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumCpPoints > 0) { print(state.files.debug, "Specific Heat Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).CpfHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).CpfLowTempValue, + state.dataFluid->RefrigData(RefrigNum).CpfLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).CpfHighTempValue, + state.dataFluid->RefrigData(RefrigNum).CpfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}\n", state.dataFluidProps->RefrigData(RefrigNum).CpfValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}\n", state.dataFluid->RefrigData(RefrigNum).CpfValues(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).CpfValues(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluid->RefrigData(RefrigNum).CpfValues(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).CpfgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfgHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).CpfgLowTempValue, + state.dataFluid->RefrigData(RefrigNum).CpfgLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).CpfgHighTempValue, + state.dataFluid->RefrigData(RefrigNum).CpfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpfgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpfgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfgValues(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluid->RefrigData(RefrigNum).CpfgValues(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumRhoPoints > 0) { print(state.files.debug, "Density Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).RhofHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).RhofLowTempValue, + state.dataFluid->RefrigData(RefrigNum).RhofLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).RhofHighTempValue, + state.dataFluid->RefrigData(RefrigNum).RhofHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhofValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhofValues(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhofValues(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluid->RefrigData(RefrigNum).RhofValues(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).RhofgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofgHighTempIndex); + state.dataFluid->RefrigData(RefrigNum).RhofgLowTempValue, + state.dataFluid->RefrigData(RefrigNum).RhofgLowTempIndex, + state.dataFluid->RefrigData(RefrigNum).RhofgHighTempValue, + state.dataFluid->RefrigData(RefrigNum).RhofgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhofgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhofgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofgValues(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluid->RefrigData(RefrigNum).RhofgValues(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts > 0 && state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts > 0 && state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts > 0) { print(state.files.debug, "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts, - state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts); + state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts, + state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts); print(state.files.debug, "Superheated Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).SHTemps(state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluid->RefrigData(RefrigNum).SHTemps(state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); print(state.files.debug, "Superheated Pressures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).SHPress(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts)); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + state.dataFluid->RefrigData(RefrigNum).SHPress(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).HshValues(Loop, Loop1)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop, state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluid->RefrigData(RefrigNum).HshValues(Loop, state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop, Loop1)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop, state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop, state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).HshValues(Loop1, Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HshValues(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + state.dataFluid->RefrigData(RefrigNum).HshValues(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts, Loop)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop1, Loop)); } print( state.files.debug, ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + state.dataFluid->RefrigData(RefrigNum).RhoshValues(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts, Loop)); } } @@ -5393,184 +5393,184 @@ namespace FluidProperties { // ============================================ // ========= Pressure from Temperatures - print(state.files.debug, "Refrigerant={} **** Results ****\n", state.dataFluidProps->RefrigData(RefrigNum).Name); - if (state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints > 0) { + print(state.files.debug, "Refrigerant={} **** Results ****\n", state.dataFluid->RefrigData(RefrigNum).Name); + if (state.dataFluid->RefrigData(RefrigNum).NumPsPoints > 0) { print(state.files.debug, "Pressure Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints) + incr); + state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints) + incr); print(state.files.debug, "Saturated Pressures:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(1) - incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(1) - incr; + ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop); ReturnValue = - GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)) / 2.0; ReturnValue = - GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints); - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints); + ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints) + incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints) + incr; + ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Enthalpy from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumHPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumHPoints > 0) { print(state.files.debug, "Enthalpy Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).HTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints) + incr); + state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints) + incr); print(state.files.debug, "Saturated Enthalpy:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(1) - incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(1) - incr; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(Loop); ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).HTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)) / 2.0; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints); + Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints); ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints) + incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints) + incr; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Specific Heat from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumCpPoints > 0) { print(state.files.debug, "Specific Heat Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints) + incr); + state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints) + incr); print(state.files.debug, "Saturated Specific Heat:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(1) - incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(1) - incr; ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop); ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop) + + (state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)) / 2.0; ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints); + Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints); ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints) + incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints) + incr; ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Density from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (state.dataFluid->RefrigData(RefrigNum).NumRhoPoints > 0) { print(state.files.debug, "Density Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop + 1) - + state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints) + incr); + state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints) + incr); print(state.files.debug, "Saturated Density:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(1) - incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(1) - incr; ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop); ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)) / + state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop + 1) - + state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)) / 2.0; ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints); + Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints); ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints) + incr; + Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints) + incr; ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } } @@ -5611,15 +5611,15 @@ namespace FluidProperties { // error counters and dummy string bool ErrorFlag; // error flag for current call - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); } ErrorFlag = false; @@ -5631,11 +5631,11 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // determine array indices for LoTempIndex = FindArrayIndex(Temperature, refrig.PsTemps, refrig.PsLowTempIndex, refrig.PsHighTempIndex); @@ -5657,13 +5657,13 @@ namespace FluidProperties { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempErrCount; + ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrCount; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowSevereMessage(state, format("{}Saturation temperature is out of range for refrigerant [{}] supplied data: **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -5675,8 +5675,8 @@ namespace FluidProperties { } ShowRecurringSevereErrorAtEnd(state, std::string{RoutineName} + "Saturation temperature is out of range for refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", + state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrIndex, Temperature, Temperature, _, @@ -5722,15 +5722,15 @@ namespace FluidProperties { // error counters and dummy string bool ErrorFlag; // error flag for current call - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); } ErrorFlag = false; @@ -5742,7 +5742,7 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, + state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -5752,7 +5752,7 @@ namespace FluidProperties { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // get the array indices LoPresIndex = FindArrayIndex(Pressure, refrig.PsValues, refrig.PsLowPresIndex, refrig.PsHighPresIndex); @@ -5774,13 +5774,13 @@ namespace FluidProperties { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatPressErrCount; + ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrCount; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatPressErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowSevereMessage(state, format("{}Saturation pressure is out of range for refrigerant [{}] supplied data: **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.0R},{:.0R}]", CalledFrom, @@ -5792,8 +5792,8 @@ namespace FluidProperties { } ShowRecurringSevereErrorAtEnd(state, std::string{RoutineName} + "Saturation pressure is out of range for refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatPressErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", + state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrIndex, Pressure, Pressure, _, @@ -5834,15 +5834,15 @@ namespace FluidProperties { // FUNCTION LOCAL VARIABLE DECLARATIONS: int RefrigNum; // index for refrigerant under consideration - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } if ((Quality < 0.0) || (Quality > 1.0)) { @@ -5858,11 +5858,11 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // Apply linear interpolation function return GetInterpolatedSatProp( @@ -5907,15 +5907,15 @@ namespace FluidProperties { // error counters and dummy string - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); } if ((Quality < 0.0) || (Quality > 1.0)) { @@ -5933,11 +5933,11 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); bool ErrorFlag = false; int LoTempIndex = FindArrayIndex(Temperature, refrig.RhoTemps, refrig.RhofLowTempIndex, refrig.RhofHighTempIndex); @@ -5980,13 +5980,13 @@ namespace FluidProperties { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount; + ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowSevereMessage(state, format("{}Saturation temperature is out of range for refrigerant [{}] supplied data: **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -5998,8 +5998,8 @@ namespace FluidProperties { } ShowRecurringSevereErrorAtEnd(state, std::string{RoutineName} + "Saturation temperature is out of range for refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempDensityErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", + state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrIndex, Temperature, Temperature, _, @@ -6040,15 +6040,15 @@ namespace FluidProperties { // FUNCTION PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("GetSatSpecificHeatRefrig: "); - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatSpecificHeatRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatSpecificHeatRefrig", "properties", CalledFrom); } if ((Quality < 0.0) || (Quality > 1.0)) { @@ -6066,7 +6066,7 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, + state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -6076,7 +6076,7 @@ namespace FluidProperties { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // Apply linear interpolation function ReturnValue = GetInterpolatedSatProp(state, @@ -6147,15 +6147,15 @@ namespace FluidProperties { int HiPressIndex; // high pressure index value // see if data is there - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); } // error counters and dummy string @@ -6173,11 +6173,11 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // low index value of Temperature from table int TempIndex = FindArrayIndex(Temperature, refrig.SHTemps, 1, refrig.NumSuperTempPts); @@ -6253,20 +6253,20 @@ namespace FluidProperties { // inside the saturation dome. Best thing we can do is return saturation value if ((refrig.HshValues(LoPressIndex, TempIndex) <= 0.0) && (refrig.HshValues(HiPressIndex, TempIndex) <= 0.0) && (refrig.HshValues(LoPressIndex, HiTempIndex) <= 0.0) && (refrig.HshValues(HiPressIndex, HiTempIndex) <= 0.0)) { - ++state.dataFluidProps->SatErrCountGetSupHeatEnthalpyRefrig; + ++state.dataFluid->SatErrCountGetSupHeatEnthalpyRefrig; // set return value ReturnValue = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); // send warning if (!state.dataGlobal->WarmupFlag) { - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrCount += - state.dataFluidProps->SatErrCountGetSupHeatEnthalpyRefrig; + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrCount += + state.dataFluid->SatErrCountGetSupHeatEnthalpyRefrig; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage( state, format("{}Refrigerant [{}] is saturated at the given conditions, saturated enthalpy at given temperature returned. **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); @@ -6275,9 +6275,9 @@ namespace FluidProperties { } ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] saturated at the given conditions **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, Temperature, Temperature, _, @@ -6291,22 +6291,22 @@ namespace FluidProperties { // some checks... if (ErrCount > 0) { // send temp range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Temperature is out of range for superheated refrigerant enthalpy: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrIndex, Temperature, Temperature, _, @@ -6315,22 +6315,22 @@ namespace FluidProperties { } // send pressure range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrIndex, Pressure, Pressure, _, @@ -6398,15 +6398,15 @@ namespace FluidProperties { int LoEnthalpyIndex; // Index value of lower enthalpy from data int HiEnthalpyIndex; // Index value of higher enthalpy from data - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); } // error counters and dummy string @@ -6424,7 +6424,7 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, + state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -6434,7 +6434,7 @@ namespace FluidProperties { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // Index value of lower temperature from data int LoTempIndex = FindArrayIndex(Temperature, refrig.SHTemps, 1, refrig.NumSuperTempPts); @@ -6555,14 +6555,14 @@ namespace FluidProperties { // ** make error checks ** if (ErrCount > 0) { // send near saturation warning if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount += CurSatErrCount; + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount += CurSatErrCount; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowSevereMessage(state, format("{}Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " "temperature returned. **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant Enthalpy = {:.3R}", Enthalpy)); @@ -6572,9 +6572,9 @@ namespace FluidProperties { if (CurSatErrCount > 0) { ShowRecurringSevereErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] saturated at the given enthalpy and temperature **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrIndex, ReturnValue, ReturnValue, _, @@ -6583,22 +6583,22 @@ namespace FluidProperties { } // send temp range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Temperature is out of range for superheated refrigerant pressure: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrIndex, Temperature, Temperature, _, @@ -6607,22 +6607,22 @@ namespace FluidProperties { } // send enthalpy range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount += CurEnthalpyRangeErrCount; - if (CurEnthalpyRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount += CurEnthalpyRangeErrCount; + if (CurEnthalpyRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurEnthalpyRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Pressure is out of range for superheated refrigerant pressure: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrIndex, Enthalpy, Enthalpy, _, @@ -6674,15 +6674,15 @@ namespace FluidProperties { Real64 RefTSat; // Saturated temperature of the refrigerant. Used to check whether the refrigernat is in the superheat area Real64 Temp; // Temperature of the superheated refrigerant at the given enthalpy and pressure - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); } // Find which refrigerant (index) is being requested and then determine @@ -6694,7 +6694,7 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, + state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -6704,7 +6704,7 @@ namespace FluidProperties { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // check temperature data range and attempt to cap if necessary RefTHigh = refrig.PsHighTempValue; @@ -6714,7 +6714,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; @@ -6723,7 +6723,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempUp = RefTHigh; @@ -6732,7 +6732,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; @@ -6760,7 +6760,7 @@ namespace FluidProperties { auto f = [&state, RefrigNum, Enthalpy, Pressure](Real64 Temp) { static constexpr std::string_view RoutineNameNoSpace("GetSupHeatTempRefrigResidual"); Real64 Enthalpy_Req = Enthalpy; - std::string const &Refrigerant = state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name; + std::string const &Refrigerant = state.dataFluid->RefrigErrorTracking(RefrigNum).Name; if (std::abs(Enthalpy_Req) < 100.0) Enthalpy_Req = sign(100.0, Enthalpy_Req); int nonConstRefrigNum = RefrigNum; Real64 Enthalpy_Act = GetSupHeatEnthalpyRefrig(state, Refrigerant, Temp, Pressure, nonConstRefrigNum, RoutineNameNoSpace); @@ -6823,15 +6823,15 @@ namespace FluidProperties { int HiPressIndex; // high pressure index value // see if data is there - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { + if (state.dataFluid->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } // initialize for this call error counters and dummy string @@ -6849,11 +6849,11 @@ namespace FluidProperties { RefrigNum = FindRefrigerant(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluidProps->RefrigData(RefrigNum)); + auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); // check temperature data range and attempt to cap if necessary // low index value of Temperature from table @@ -6935,28 +6935,28 @@ namespace FluidProperties { // interpolate w.r.t. temperature ReturnValue = TempInterpRatio * DensityHigh + (1.0 - TempInterpRatio) * DensityLow; } else { // All data is at zero: we are completely inside the saturation dome. Best thing we can do is return saturation value - ++state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig; + ++state.dataFluid->SatErrCountGetSupHeatDensityRefrig; // send warning - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount += state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig; + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount += state.dataFluid->SatErrCountGetSupHeatDensityRefrig; // send warning - if (state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] is saturated at the given conditions, saturated density at given temperature returned. **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); ShowContinueError(state, format("Returned Density value = {:.3R}", saturated_density)); ShowContinueErrorTimeStamp(state, ""); } - if (state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig > 0) { + if (state.dataFluid->SatErrCountGetSupHeatDensityRefrig > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + ": Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] saturated at the given conditions **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, Temperature, Temperature, _, @@ -6970,23 +6970,23 @@ namespace FluidProperties { // some checks... if (ErrCount > 0) { // send temp range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + ": Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Temperature is out of range for superheated refrigerant density: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrIndex, Temperature, Temperature, _, @@ -6995,22 +6995,22 @@ namespace FluidProperties { } // send pressure range error if flagged - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount <= - state.dataFluidProps->RefrigerantErrorLimitTest) { + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount <= + state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", RoutineName, - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name)); + state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + ": Refrigerant [" + - state.dataFluidProps->RefrigErrorTracking(RefrigNum).Name + + state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] Pressure is out of range for superheated refrigerant density: values capped **", - state.dataFluidProps->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrIndex, + state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrIndex, Pressure, Pressure, _, @@ -7044,7 +7044,7 @@ namespace FluidProperties { DISABLE_WARNING_POP std::uint64_t const hash(T_tag & t_sh_cache_mask); - auto &cTsh(state.dataFluidProps->cached_t_sh[hash]); + auto &cTsh(state.dataFluid->cached_t_sh[hash]); if (cTsh.iT != T_tag) { cTsh.iT = T_tag; @@ -7092,16 +7092,16 @@ namespace FluidProperties { static constexpr std::string_view RoutineName("GetSpecificHeatGlycol: "); // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum(0); - if (state.dataFluidProps->NumOfGlycols == 0) + if (state.dataFluid->NumOfGlycols == 0) ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { @@ -7110,16 +7110,16 @@ namespace FluidProperties { GlycolNum = FindGlycol(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); } GlycolIndex = GlycolNum; } - auto const &glycol_data(state.dataFluidProps->GlycolData(GlycolIndex)); + auto const &glycol_data(state.dataFluid->GlycolData(GlycolIndex)); // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!glycol_data.CpDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, + state.dataFluid->NumOfGlycols, GlycolNum, glycol_data.CpDataPresent, Glycol, @@ -7131,9 +7131,9 @@ namespace FluidProperties { // Now determine the value of specific heat using interpolation if (Temperature < glycol_data.CpLowTempValue) { // Temperature too low if (!state.dataGlobal->WarmupFlag) { - state.dataFluidProps->LowTempLimitErrGetSpecificHeatGlycol_raw = - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrCount; - if (state.dataFluidProps->LowTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProps->GlycolErrorLimitTest) { + state.dataFluid->LowTempLimitErrGetSpecificHeatGlycol_raw = + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrCount; + if (state.dataFluid->LowTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluid->GlycolErrorLimitTest) { ShowWarningMessage(state, format("{}Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", RoutineName, @@ -7149,7 +7149,7 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + glycol_data.Name + "] specific heat **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrIndex, + state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrIndex, Temperature, Temperature, _, @@ -7159,9 +7159,9 @@ namespace FluidProperties { return glycol_data.CpValues(glycol_data.CpLowTempIndex); } else if (Temperature > glycol_data.CpHighTempValue) { // Temperature too high if (!state.dataGlobal->WarmupFlag) { - state.dataFluidProps->HighTempLimitErrGetSpecificHeatGlycol_raw = - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrCount; - if (state.dataFluidProps->HighTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProps->GlycolErrorLimitTest) { + state.dataFluid->HighTempLimitErrGetSpecificHeatGlycol_raw = + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrCount; + if (state.dataFluid->HighTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluid->GlycolErrorLimitTest) { ShowWarningMessage( state, format("{}Temperature is out of range (too high) for fluid [{}] specific heat **", RoutineName, glycol_data.Name)); ShowContinueError(state, @@ -7175,7 +7175,7 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + glycol_data.Name + "] specific heat **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrIndex, + state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrIndex, Temperature, Temperature, _, @@ -7244,15 +7244,15 @@ namespace FluidProperties { bool HighErrorThisTime = false; // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) - ReportFatalGlycolErrors(state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); + if (state.dataFluid->NumOfGlycols == 0) + ReportFatalGlycolErrors(state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { @@ -7261,17 +7261,17 @@ namespace FluidProperties { GlycolNum = FindGlycol(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); } GlycolIndex = GlycolNum; } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluidProps->GlycolData(GlycolIndex).RhoDataPresent) { + if (!state.dataFluid->GlycolData(GlycolIndex).RhoDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, + state.dataFluid->NumOfGlycols, GlycolNum, - state.dataFluidProps->GlycolData(GlycolIndex).RhoDataPresent, + state.dataFluid->GlycolData(GlycolIndex).RhoDataPresent, Glycol, "GetDensityGlycol", "density", @@ -7279,25 +7279,25 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempValue) { // Temperature too low + if (Temperature < state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).RhoValues(state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempIndex); - } else if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).RhoHighTempValue) { // Temperature too high + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex); + } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).RhoValues(state.dataFluidProps->GlycolData(GlycolIndex).RhoHighTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).RhoValues(state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex); // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempIndex + 1; - Loop <= state.dataFluidProps->GlycolData(GlycolIndex).RhoHighTempIndex; + for (int Loop = state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex + 1; + Loop <= state.dataFluid->GlycolData(GlycolIndex).RhoHighTempIndex; ++Loop) { - if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).RhoTemps(Loop)) continue; + if (Temperature > state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop)) continue; ReturnValue = GetInterpValue(state, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).RhoTemps(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).RhoTemps(Loop), - state.dataFluidProps->GlycolData(GlycolIndex).RhoValues(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).RhoValues(Loop)); + state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop), + state.dataFluid->GlycolData(GlycolIndex).RhoValues(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).RhoValues(Loop)); break; // DO loop } } @@ -7306,32 +7306,32 @@ namespace FluidProperties { if (!state.dataGlobal->WarmupFlag) { if (LowErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetDensityGlycol = state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; + state.dataFluid->LowTempLimitErrGetDensityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetDensityGlycol = state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; + state.dataFluid->HighTempLimitErrGetDensityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetDensityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetDensityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too low) for fluid [{}] density **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).RhoHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] density **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityLowErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] density **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrIndex, Temperature, Temperature, _, @@ -7339,24 +7339,24 @@ namespace FluidProperties { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetDensityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetDensityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too high) for fluid [{}] density **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).RhoLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).RhoHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] density **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).DensityHighErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] density **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrIndex, Temperature, Temperature, _, @@ -7407,16 +7407,16 @@ namespace FluidProperties { bool HighErrorThisTime = false; // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) + if (state.dataFluid->NumOfGlycols == 0) ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { @@ -7425,17 +7425,17 @@ namespace FluidProperties { GlycolNum = FindGlycol(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); } GlycolIndex = GlycolNum; } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluidProps->GlycolData(GlycolIndex).CondDataPresent) { + if (!state.dataFluid->GlycolData(GlycolIndex).CondDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, + state.dataFluid->NumOfGlycols, GlycolNum, - state.dataFluidProps->GlycolData(GlycolIndex).CondDataPresent, + state.dataFluid->GlycolData(GlycolIndex).CondDataPresent, Glycol, "GetConductivityGlycol", "conductivity", @@ -7443,25 +7443,25 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempValue) { // Temperature too low + if (Temperature < state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).CondValues(state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempIndex); - } else if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).CondHighTempValue) { // Temperature too high + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex); + } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).CondValues(state.dataFluidProps->GlycolData(GlycolIndex).CondHighTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).CondValues(state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex); // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempIndex + 1; - Loop <= state.dataFluidProps->GlycolData(GlycolIndex).CondHighTempIndex; + for (int Loop = state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex + 1; + Loop <= state.dataFluid->GlycolData(GlycolIndex).CondHighTempIndex; ++Loop) { - if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).CondTemps(Loop)) continue; + if (Temperature > state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop)) continue; ReturnValue = GetInterpValue(state, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).CondTemps(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).CondTemps(Loop), - state.dataFluidProps->GlycolData(GlycolIndex).CondValues(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).CondValues(Loop)); + state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop), + state.dataFluid->GlycolData(GlycolIndex).CondValues(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).CondValues(Loop)); break; // DO loop } } @@ -7470,34 +7470,34 @@ namespace FluidProperties { if (!state.dataGlobal->WarmupFlag) { if (LowErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetConductivityGlycol = - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; + state.dataFluid->LowTempLimitErrGetConductivityGlycol = + state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetConductivityGlycol = - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; + state.dataFluid->HighTempLimitErrGetConductivityGlycol = + state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetConductivityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetConductivityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too low) for fluid [{}] conductivity **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).CondHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] conductivity **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityLowErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] conductivity **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrIndex, Temperature, Temperature, _, @@ -7505,24 +7505,24 @@ namespace FluidProperties { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetConductivityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetConductivityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too high) for fluid [{}] conductivity **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).CondLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).CondHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] conductivity **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ConductivityHighErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] conductivity **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrIndex, Temperature, Temperature, _, @@ -7573,16 +7573,16 @@ namespace FluidProperties { bool HighErrorThisTime = false; // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) + if (state.dataFluid->NumOfGlycols == 0) ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { @@ -7591,17 +7591,17 @@ namespace FluidProperties { GlycolNum = FindGlycol(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); } GlycolIndex = GlycolNum; } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluidProps->GlycolData(GlycolIndex).ViscDataPresent) { + if (!state.dataFluid->GlycolData(GlycolIndex).ViscDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, + state.dataFluid->NumOfGlycols, GlycolNum, - state.dataFluidProps->GlycolData(GlycolIndex).ViscDataPresent, + state.dataFluid->GlycolData(GlycolIndex).ViscDataPresent, Glycol, "GetViscosityGlycol", "viscosity", @@ -7609,25 +7609,25 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempValue) { // Temperature too low + if (Temperature < state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).ViscValues(state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempIndex); - } else if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).ViscHighTempValue) { // Temperature too high + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex); + } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).ViscValues(state.dataFluidProps->GlycolData(GlycolIndex).ViscHighTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluidProps->GlycolData(GlycolIndex).ViscValues(state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempIndex); + ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex); // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempIndex + 1; - Loop <= state.dataFluidProps->GlycolData(GlycolIndex).ViscHighTempIndex; + for (int Loop = state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex + 1; + Loop <= state.dataFluid->GlycolData(GlycolIndex).ViscHighTempIndex; ++Loop) { - if (Temperature > state.dataFluidProps->GlycolData(GlycolIndex).ViscTemps(Loop)) continue; + if (Temperature > state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop)) continue; ReturnValue = GetInterpValue(state, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).ViscTemps(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).ViscTemps(Loop), - state.dataFluidProps->GlycolData(GlycolIndex).ViscValues(Loop - 1), - state.dataFluidProps->GlycolData(GlycolIndex).ViscValues(Loop)); + state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop), + state.dataFluid->GlycolData(GlycolIndex).ViscValues(Loop - 1), + state.dataFluid->GlycolData(GlycolIndex).ViscValues(Loop)); break; // DO loop } } @@ -7636,33 +7636,33 @@ namespace FluidProperties { if (!state.dataGlobal->WarmupFlag) { if (LowErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetViscosityGlycol = state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; + state.dataFluid->LowTempLimitErrGetViscosityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetViscosityGlycol = - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; + ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; + state.dataFluid->HighTempLimitErrGetViscosityGlycol = + state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetViscosityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetViscosityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too low) for fluid [{}] viscosity **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).ViscHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] viscosity **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityLowErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] viscosity **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrIndex, Temperature, Temperature, _, @@ -7670,24 +7670,24 @@ namespace FluidProperties { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetViscosityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetViscosityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too high) for fluid [{}] viscosity **", RoutineName, - state.dataFluidProps->GlycolData(GlycolIndex).Name)); + state.dataFluid->GlycolData(GlycolIndex).Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluidProps->GlycolData(GlycolIndex).ViscLowTempValue, - state.dataFluidProps->GlycolData(GlycolIndex).ViscHighTempValue)); + state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue, + state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluidProps->GlycolData(GlycolIndex).Name + "] viscosity **", - state.dataFluidProps->GlycolErrorTracking(GlycolIndex).ViscosityHighErrIndex, + state.dataFluid->GlycolData(GlycolIndex).Name + "] viscosity **", + state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrIndex, Temperature, Temperature, _, @@ -7728,17 +7728,17 @@ namespace FluidProperties { int FindRefrigerant; // Make sure we have already read in the input - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // Check to see if this glycol shows up in the glycol data - int Found = Util::FindItemInList(Util::makeUPPER(Refrigerant), state.dataFluidProps->RefrigData); + int Found = Util::FindItemInList(Util::makeUPPER(Refrigerant), state.dataFluid->RefrigData); if (Found > 0) { FindRefrigerant = Found; - state.dataFluidProps->RefrigUsed(Found) = true; + state.dataFluid->RefrigUsed(Found) = true; } else { // not found - errors handled in calling proceedure FindRefrigerant = 0; } @@ -7770,19 +7770,19 @@ namespace FluidProperties { int FindGlycol; // Make sure we have already read in the input - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // Check to see if this glycol shows up in the glycol data int Found = Util::FindItemInList(Util::makeUPPER(Glycol), - state.dataFluidProps->GlycolData, - state.dataFluidProps->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs + state.dataFluid->GlycolData, + state.dataFluid->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs if (Found > 0) { FindGlycol = Found; - state.dataFluidProps->GlycolUsed(Found) = true; + state.dataFluid->GlycolUsed(Found) = true; } else { // return zero - error checking in calling proceedure FindGlycol = 0; } @@ -7813,8 +7813,8 @@ namespace FluidProperties { // Check to see if this glycol shows up in the glycol data // ArrayLength = SIZE(GlycolData) - if (Idx > 0 && Idx <= state.dataFluidProps->NumOfGlycols) { - return state.dataFluidProps->GlycolData(Idx).Name; + if (Idx > 0 && Idx <= state.dataFluid->NumOfGlycols) { + return state.dataFluid->GlycolData(Idx).Name; } else { // return blank - error checking in calling proceedure return ""; } @@ -7986,9 +7986,9 @@ namespace FluidProperties { } if (ErrorFlag && (CalledFrom != "ReportAndTestRefrigerants")) { - ++state.dataFluidProps->TempRangeErrCountGetInterpolatedSatProp; + ++state.dataFluid->TempRangeErrCountGetInterpolatedSatProp; // send warning - if (state.dataFluidProps->TempRangeErrCountGetInterpolatedSatProp <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (state.dataFluid->TempRangeErrCountGetInterpolatedSatProp <= state.dataFluid->RefrigerantErrorLimitTest) { ShowWarningError(state, "GetInterpolatedSatProp: Saturation temperature for interpolation is out of range of data supplied: **"); ShowContinueErrorTimeStamp(state, fmt::format(" Called from:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); @@ -7996,7 +7996,7 @@ namespace FluidProperties { } else { ShowRecurringWarningErrorAtEnd(state, "GetInterpolatedSatProp: Refrigerant temperature for interpolation out of range error", - state.dataFluidProps->TempRangeErrIndexGetInterpolatedSatProp, + state.dataFluid->TempRangeErrIndexGetInterpolatedSatProp, Temperature, Temperature, _, @@ -8024,20 +8024,20 @@ namespace FluidProperties { // Return value int CheckFluidPropertyName; - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } // Item must be either in Refrigerant or Glycol list int Found = 0; - if (state.dataFluidProps->NumOfRefrigerants > 0) { - Found = Util::FindItemInList(NameToCheck, state.dataFluidProps->RefrigData); + if (state.dataFluid->NumOfRefrigerants > 0) { + Found = Util::FindItemInList(NameToCheck, state.dataFluid->RefrigData); } if (Found == 0) { - if (state.dataFluidProps->NumOfGlycols > 0) { + if (state.dataFluid->NumOfGlycols > 0) { Found = Util::FindItemInList( - NameToCheck, state.dataFluidProps->GlycolData, state.dataFluidProps->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs + NameToCheck, state.dataFluid->GlycolData, state.dataFluid->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs } } @@ -8060,16 +8060,16 @@ namespace FluidProperties { bool NeedOrphanMessage = true; int NumUnusedRefrig = 0; - for (int Item = 1; Item <= state.dataFluidProps->NumOfRefrigerants; ++Item) { - if (state.dataFluidProps->RefrigUsed(Item)) continue; - if (Util::SameString(state.dataFluidProps->RefrigData(Item).Name, Steam)) continue; + for (int Item = 1; Item <= state.dataFluid->NumOfRefrigerants; ++Item) { + if (state.dataFluid->RefrigUsed(Item)) continue; + if (Util::SameString(state.dataFluid->RefrigData(Item).Name, Steam)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Refrigerant={}", state.dataFluidProps->RefrigData(Item).Name)); + ShowMessage(state, format("Refrigerant={}", state.dataFluid->RefrigData(Item).Name)); } else { ++NumUnusedRefrig; } @@ -8077,18 +8077,18 @@ namespace FluidProperties { int NumUnusedGlycol = 0; - for (int Item = 1; Item <= state.dataFluidProps->NumOfGlycols; ++Item) { - if (state.dataFluidProps->GlycolUsed(Item)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, Water)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, EthyleneGlycol)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, PropyleneGlycol)) continue; + for (int Item = 1; Item <= state.dataFluid->NumOfGlycols; ++Item) { + if (state.dataFluid->GlycolUsed(Item)) continue; + if (Util::SameString(state.dataFluid->GlycolData(Item).Name, Water)) continue; + if (Util::SameString(state.dataFluid->GlycolData(Item).Name, EthyleneGlycol)) continue; + if (Util::SameString(state.dataFluid->GlycolData(Item).Name, PropyleneGlycol)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Glycol={}", state.dataFluidProps->GlycolData(Item).Name)); + ShowMessage(state, format("Glycol={}", state.dataFluid->GlycolData(Item).Name)); } else { ++NumUnusedGlycol; } @@ -8193,28 +8193,28 @@ namespace FluidProperties { { // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } if (FluidIndex > 0) { - MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoLowTempValue; - MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoHighTempValue; + MinTempLimit = state.dataFluid->GlycolData(FluidIndex).RhoLowTempValue; + MaxTempLimit = state.dataFluid->GlycolData(FluidIndex).RhoHighTempValue; } } void GetFluidSpecificHeatTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { + if (state.dataFluid->GetInput) { GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; + state.dataFluid->GetInput = false; } if (FluidIndex > 0) { - MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpLowTempValue; - MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpHighTempValue; + MinTempLimit = state.dataFluid->GlycolData(FluidIndex).CpLowTempValue; + MaxTempLimit = state.dataFluid->GlycolData(FluidIndex).CpHighTempValue; } } @@ -8229,19 +8229,19 @@ namespace FluidProperties { } Real64 GlycolAPI::specificHeat(EnergyPlusData &state, Real64 temperature) { - return FluidProperties::GetSpecificHeatGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return Fluid::GetSpecificHeatGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::density(EnergyPlusData &state, Real64 temperature) { - return FluidProperties::GetDensityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return Fluid::GetDensityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::conductivity(EnergyPlusData &state, Real64 temperature) { - return FluidProperties::GetConductivityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return Fluid::GetConductivityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::viscosity(EnergyPlusData &state, Real64 temperature) { - return FluidProperties::GetViscosityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return Fluid::GetViscosityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } RefrigerantAPI::RefrigerantAPI(EnergyPlusData &state, std::string const &refrigName) @@ -8255,37 +8255,37 @@ namespace FluidProperties { } Real64 RefrigerantAPI::saturationPressure(EnergyPlusData &state, Real64 temperature) { - return FluidProperties::GetSatPressureRefrig(state, this->rName, temperature, this->rIndex, this->cf); + return Fluid::GetSatPressureRefrig(state, this->rName, temperature, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturationTemperature(EnergyPlusData &state, Real64 pressure) { - return FluidProperties::GetSatTemperatureRefrig(state, this->rName, pressure, this->rIndex, this->cf); + return Fluid::GetSatTemperatureRefrig(state, this->rName, pressure, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedEnthalpy(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return FluidProperties::GetSatEnthalpyRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return Fluid::GetSatEnthalpyRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedDensity(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return FluidProperties::GetSatDensityRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return Fluid::GetSatDensityRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedSpecificHeat(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return FluidProperties::GetSatSpecificHeatRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return Fluid::GetSatSpecificHeatRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedEnthalpy(EnergyPlusData &state, Real64 temperature, Real64 pressure) { - return FluidProperties::GetSupHeatEnthalpyRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); + return Fluid::GetSupHeatEnthalpyRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedPressure(EnergyPlusData &state, Real64 temperature, Real64 enthalpy) { - return FluidProperties::GetSupHeatPressureRefrig(state, this->rName, temperature, enthalpy, this->rIndex, this->cf); + return Fluid::GetSupHeatPressureRefrig(state, this->rName, temperature, enthalpy, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedDensity(EnergyPlusData &state, Real64 temperature, Real64 pressure) { - return FluidProperties::GetSupHeatDensityRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); + return Fluid::GetSupHeatDensityRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); } -} // namespace FluidProperties +} // namespace Fluid } // namespace EnergyPlus diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index c0e77cc9006..fbb86d00dbe 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -67,7 +67,7 @@ namespace EnergyPlus { // Forward declarations struct EnergyPlusData; -namespace FluidProperties { +namespace Fluid { int constexpr EthyleneGlycolIndex = -2; int constexpr PropyleneGlycolIndex = -1; @@ -622,9 +622,9 @@ namespace FluidProperties { Real64 superHeatedDensity(EnergyPlusData &state, Real64 temperature, Real64 pressure); }; -} // namespace FluidProperties +} // namespace Fluid -struct FluidPropertiesData : BaseGlobalStruct +struct FluidData : BaseGlobalStruct { bool GetInput = true; // Used to get the input once only @@ -637,11 +637,11 @@ struct FluidPropertiesData : BaseGlobalStruct Array1D_bool RefrigUsed; Array1D_bool GlycolUsed; - Array1D RefrigData; - Array1D RefrigErrorTracking; - Array1D GlyRawData; - Array1D GlycolData; - Array1D GlycolErrorTracking; + Array1D RefrigData; + Array1D RefrigErrorTracking; + Array1D GlyRawData; + Array1D GlycolData; + Array1D GlycolErrorTracking; int SatErrCountGetSupHeatEnthalpyRefrig = 0; int SatErrCountGetSupHeatDensityRefrig = 0; @@ -659,18 +659,18 @@ struct FluidPropertiesData : BaseGlobalStruct int TempRangeErrIndexGetInterpolatedSatProp = 0; #ifdef EP_cache_GlycolSpecificHeat - std::array cached_t_sh; + std::array cached_t_sh; #endif void init_state(EnergyPlusData &state) override { - FluidProperties::GetFluidPropertiesData(state); + Fluid::GetFluidPropertiesData(state); this->GetInput = false; } void clear_state() override { - new (this) FluidPropertiesData(); + new (this) FluidData(); } }; diff --git a/src/EnergyPlus/FuelCellElectricGenerator.cc b/src/EnergyPlus/FuelCellElectricGenerator.cc index 47a55dcc2b1..6a9a94be210 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.cc +++ b/src/EnergyPlus/FuelCellElectricGenerator.cc @@ -3032,7 +3032,7 @@ namespace FuelCellElectricGenerator { this->ExhaustHX.THXexh = TprodGasIn - this->ExhaustHX.qHX / (NdotGas * CpProdGasMol * 1000.0); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, TwaterIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3368,7 +3368,7 @@ namespace FuelCellElectricGenerator { this->Inverter.PCUlosses = 0.0; this->Inverter.QairIntake = 0.0; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, DataGenerators::InitHRTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index 941c5288275..86bc6ce5de9 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -1130,7 +1130,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getUnitaryHeatOnly); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -1672,7 +1672,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -2129,7 +2129,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -3138,7 +3138,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -3953,7 +3953,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -4786,7 +4786,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidIndex, @@ -4812,7 +4812,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -4849,7 +4849,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidIndex, @@ -4874,7 +4874,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxSuppCoilFluidFlow *= SteamDensity; } @@ -4917,7 +4917,7 @@ namespace Furnaces { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidIndex, @@ -4936,7 +4936,7 @@ namespace Furnaces { CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -4955,7 +4955,7 @@ namespace Furnaces { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidIndex, @@ -4973,7 +4973,7 @@ namespace Furnaces { CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } diff --git a/src/EnergyPlus/GroundHeatExchangers.cc b/src/EnergyPlus/GroundHeatExchangers.cc index 7c86b973419..f9d102c5e20 100644 --- a/src/EnergyPlus/GroundHeatExchangers.cc +++ b/src/EnergyPlus/GroundHeatExchangers.cc @@ -1137,12 +1137,12 @@ void GLHEVert::calcShortTimestepGFunctions(EnergyPlusData &state) Real64 bh_equivalent_resistance_convection = bhResistance - bh_equivalent_resistance_tube_grout; Real64 initial_temperature = this->inletTemp; - Real64 cpFluid_init = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cpFluid_init = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, initial_temperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidDensity_init = FluidProperties::GetDensityGlycol(state, + Real64 fluidDensity_init = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, initial_temperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2004,7 +2004,7 @@ void GLHEBase::calcGroundHeatExchanger(EnergyPlusData &state) this->inletTemp = state.dataLoopNodes->Node(this->inletNodeNum).Temp; - Real64 cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2275,7 +2275,7 @@ void GLHEBase::updateGHX(EnergyPlusData &state) state.dataLoopNodes->Node(this->outletNodeNum).Temp = this->outletTemp; state.dataLoopNodes->Node(this->outletNodeNum).Enthalpy = - this->outletTemp * FluidProperties::GetSpecificHeatGlycol(state, + this->outletTemp * Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->outletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2284,7 +2284,7 @@ void GLHEBase::updateGHX(EnergyPlusData &state) Real64 GLHEdeltaTemp = std::abs(this->outletTemp - this->inletTemp); if (GLHEdeltaTemp > deltaTempLimit && this->numErrorCalls < state.dataGroundHeatExchanger->numVerticalGLHEs && !state.dataGlobal->WarmupFlag) { - Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 fluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2636,7 +2636,7 @@ Real64 GLHEVert::calcHXResistance(EnergyPlusData &state) } else { std::string_view const RoutineName = "calcBHResistance"; - Real64 const cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2671,17 +2671,17 @@ Real64 GLHEVert::calcPipeConvectionResistance(EnergyPlusData &state) // Get fluid props this->inletTemp = state.dataLoopNodes->Node(this->inletNodeNum).Temp; - Real64 const cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const kFluid = FluidProperties::GetConductivityGlycol(state, + Real64 const kFluid = Fluid::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const fluidViscosity = FluidProperties::GetViscosityGlycol(state, + Real64 const fluidViscosity = Fluid::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2775,22 +2775,22 @@ Real64 GLHESlinky::calcHXResistance(EnergyPlusData &state) constexpr Real64 B = 350; constexpr Real64 laminarNusseltNo = 4.364; - Real64 cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 kFluid = FluidProperties::GetConductivityGlycol(state, + Real64 kFluid = Fluid::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 fluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidViscosity = FluidProperties::GetViscosityGlycol(state, + Real64 fluidViscosity = Fluid::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2951,7 +2951,7 @@ void GLHEVert::initEnvironment(EnergyPlusData &state, [[maybe_unused]] Real64 co std::string_view const RoutineName = "initEnvironment"; this->myEnvrnFlag = false; - Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 fluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3026,7 +3026,7 @@ void GLHESlinky::initEnvironment(EnergyPlusData &state, Real64 const CurTime) std::string_view const RoutineName = "initEnvironment"; this->myEnvrnFlag = false; - Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 fluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HVACControllers.cc b/src/EnergyPlus/HVACControllers.cc index a0a1ba563e2..635bb5e5f83 100644 --- a/src/EnergyPlus/HVACControllers.cc +++ b/src/EnergyPlus/HVACControllers.cc @@ -1021,7 +1021,7 @@ void InitController(EnergyPlusData &state, int const ControlNum, bool &IsConverg // Do the Begin Environment initializations if (state.dataGlobal->BeginEnvrnFlag && MyEnvrnFlag(ControlNum)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisController.ActuatedNodePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(thisController.ActuatedNodePlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HVACCooledBeam.cc b/src/EnergyPlus/HVACCooledBeam.cc index 635b0f71340..14f38030df9 100644 --- a/src/EnergyPlus/HVACCooledBeam.cc +++ b/src/EnergyPlus/HVACCooledBeam.cc @@ -508,7 +508,7 @@ namespace HVACCooledBeam { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -647,8 +647,8 @@ namespace HVACCooledBeam { // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::MyPlantSizingIndex; using PlantUtilities::RegisterPlantCompDesignFlow; @@ -1021,8 +1021,8 @@ namespace HVACCooledBeam { // na // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // Locals diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index 47961c0e382..b6d8b3ba734 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -734,8 +734,8 @@ namespace FourPipeBeam { // Using using namespace DataSizing; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::MyPlantSizingIndex; using PlantUtilities::RegisterPlantCompDesignFlow; using Psychrometrics::PsyCpAirFnW; @@ -871,7 +871,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -884,7 +884,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -951,7 +951,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -964,7 +964,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = FluidProperties::GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -1034,7 +1034,7 @@ namespace FourPipeBeam { } if (this->beamCoolingPresent) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -1044,7 +1044,7 @@ namespace FourPipeBeam { PlantUtilities::InitComponentNodes(state, 0.0, this->mDotDesignCW, this->cWInNodeNum, this->cWOutNodeNum); } if (this->beamHeatingPresent) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -1244,8 +1244,8 @@ namespace FourPipeBeam { { // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // Locals diff --git a/src/EnergyPlus/HVACInterfaceManager.cc b/src/EnergyPlus/HVACInterfaceManager.cc index d292194eacc..54a1e257a13 100644 --- a/src/EnergyPlus/HVACInterfaceManager.cc +++ b/src/EnergyPlus/HVACInterfaceManager.cc @@ -506,7 +506,7 @@ void UpdatePlantLoopInterface(EnergyPlusData &state, Real64 OldTankOutletTemp = state.dataLoopNodes->Node(OtherLoopSideInletNode).Temp; // calculate the specific heat - Real64 Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, OldTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // update the enthalpy @@ -660,7 +660,7 @@ void UpdateHalfLoopInletTemp(EnergyPlusData &state, int const LoopNum, const Dat Real64 LastTankOutletTemp = state.dataPlnt->PlantLoop(LoopNum).LoopSide(TankOutletLoopSide).LastTempInterfaceTankOutlet; // calculate the specific heat for the capacitance calculation - Real64 Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LastTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // set the fraction of loop mass assigned to each half loop outlet capacitance ('tank') calculation @@ -791,7 +791,7 @@ void UpdateCommonPipe(EnergyPlusData &state, Real64 LastTankOutletTemp = state.dataPlnt->PlantLoop(LoopNum).LoopSide(TankOutletLoopSide).LastTempInterfaceTankOutlet; // calculate the specific heat for the capacitance calculation - Real64 Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LastTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // set the fraction of loop mass assigned to each half loop outlet capacitance ('tank') calculation diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index 3f243b24ac4..b203328f07f 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -904,7 +904,7 @@ namespace HVACMultiSpeedHeatPump { thisMSHP.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.HeatCoilNum, errFlag); if (thisMSHP.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, routineName); thisMSHP.MaxCoilFluidFlow *= SteamDensity; } @@ -1176,7 +1176,7 @@ namespace HVACMultiSpeedHeatPump { thisMSHP.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.SuppHeatCoilNum, errFlag); if (thisMSHP.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, routineName); thisMSHP.MaxSuppCoilFluidFlow *= SteamDensity; } @@ -1841,7 +1841,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidIndex, @@ -1874,7 +1874,7 @@ namespace HVACMultiSpeedHeatPump { if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed // TODO: Why do you want to re-look this up? - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow *= SteamDensity; } @@ -1903,7 +1903,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidIndex, @@ -1936,7 +1936,7 @@ namespace HVACMultiSpeedHeatPump { SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow *= SteamDensity; } @@ -2058,7 +2058,7 @@ namespace HVACMultiSpeedHeatPump { if ((MSHeatPump(MSHeatPumpNum).HeatRecActive) && (!MSHeatPump(MSHeatPumpNum).MyPlantScantFlag)) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidIndex, @@ -2081,7 +2081,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidIndex, @@ -2106,7 +2106,7 @@ namespace HVACMultiSpeedHeatPump { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -2127,7 +2127,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = FluidProperties::GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -2153,7 +2153,7 @@ namespace HVACMultiSpeedHeatPump { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -3945,7 +3945,7 @@ namespace HVACMultiSpeedHeatPump { if (HeatRecMassFlowRate > 0.0) { // Heat reclaim water inlet specific heat [J/kg-K] - Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol( + Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidName, HeatRecInletTemp, diff --git a/src/EnergyPlus/HVACSingleDuctInduc.cc b/src/EnergyPlus/HVACSingleDuctInduc.cc index a7fd16f81b8..d5171cd2d17 100644 --- a/src/EnergyPlus/HVACSingleDuctInduc.cc +++ b/src/EnergyPlus/HVACSingleDuctInduc.cc @@ -620,7 +620,7 @@ namespace HVACSingleDuctInduc { int HotConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode; if (HotConNode > 0 && !state.dataHVACSingleDuctInduc->MyPlantScanFlag(IUNum)) { - rho = FluidProperties::GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -641,7 +641,7 @@ namespace HVACSingleDuctInduc { int ColdConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode; if (ColdConNode > 0) { - rho = FluidProperties::GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, @@ -850,14 +850,14 @@ namespace HVACSingleDuctInduc { state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU); } state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesHeatingLoad = DesCoilLoad; - Cp = FluidProperties::GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -985,14 +985,14 @@ namespace HVACSingleDuctInduc { state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneSizThermSetPtHi); } state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesCoolingLoad = DesCoilLoad; - Cp = FluidProperties::GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, 5.0, diff --git a/src/EnergyPlus/HVACSizingSimulationManager.cc b/src/EnergyPlus/HVACSizingSimulationManager.cc index 9dd268ccea2..5eb14ef0172 100644 --- a/src/EnergyPlus/HVACSizingSimulationManager.cc +++ b/src/EnergyPlus/HVACSizingSimulationManager.cc @@ -97,12 +97,12 @@ void HVACSizingSimulationManager::CreateNewCoincidentPlantAnalysisObject(EnergyP for (int i = 1; i <= state.dataPlnt->TotNumLoops; ++i) { if (PlantLoopName == state.dataPlnt->PlantLoop(i).Name) { // found it - density = FluidProperties::GetDensityGlycol(state, + density = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(i).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(i).FluidIndex, "createNewCoincidentPlantAnalysisObject"); - cp = FluidProperties::GetSpecificHeatGlycol(state, + cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(i).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(i).FluidIndex, diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.cc b/src/EnergyPlus/HVACUnitaryBypassVAV.cc index b12b3213faf..f1ae2872352 100644 --- a/src/EnergyPlus/HVACUnitaryBypassVAV.cc +++ b/src/EnergyPlus/HVACUnitaryBypassVAV.cc @@ -901,7 +901,7 @@ namespace HVACUnitaryBypassVAV { thisCBVAV.CoilControlNode = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).SteamInletNodeNum; thisCBVAV.MaxHeatCoilFluidFlow = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).MaxSteamVolFlowRate; int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( + Real64 SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, getUnitaryHeatCoolVAVChangeoverBypass); if (thisCBVAV.MaxHeatCoilFluidFlow > 0.0) { thisCBVAV.MaxHeatCoilFluidFlow = thisCBVAV.MaxHeatCoilFluidFlow * SteamDensity; @@ -1382,7 +1382,7 @@ namespace HVACUnitaryBypassVAV { cBVAV.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound); if (cBVAV.MaxHeatCoilFluidFlow > 0.0) { - Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 FluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidIndex, @@ -1405,7 +1405,7 @@ namespace HVACUnitaryBypassVAV { if (cBVAV.MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = FluidProperties::GetSatDensityRefrig( + Real64 FluidDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, RoutineName); cBVAV.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cBVAV.HeatCoilIndex, ErrorsFound) * FluidDensity; } @@ -1480,7 +1480,7 @@ namespace HVACUnitaryBypassVAV { ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name)); } if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, + Real64 FluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidIndex, @@ -1502,7 +1502,7 @@ namespace HVACUnitaryBypassVAV { } if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = FluidProperties::GetSatDensityRefrig( + Real64 FluidDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, RoutineName); cBVAV.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index bce02535fa9..155b4cd2731 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -358,7 +358,7 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond) // If terminal units require more capacity than can be delivered by condenser, a limit is set. using Curve::CurveValue; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; using Psychrometrics::RhoH2O; @@ -2484,11 +2484,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) // Refrigerant type thisVrfFluidCtrl.RefrigerantName = cAlphaArgs(4); - if (state.dataFluidProps->GetInput) { - EnergyPlus::FluidProperties::GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - if (Util::FindItemInList(thisVrfFluidCtrl.RefrigerantName, state.dataFluidProps->RefrigData, state.dataFluidProps->NumOfRefrigerants) == 0) { + if (Util::FindItemInList(thisVrfFluidCtrl.RefrigerantName, state.dataFluid->RefrigData, state.dataFluid->NumOfRefrigerants) == 0) { ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrl.Name); ShowContinueError(state, "Illegal " + cAlphaFieldNames(4) + " = " + cAlphaArgs(4)); ErrorsFound = true; @@ -2883,11 +2879,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) // Refrigerant type thisVrfFluidCtrlHR.RefrigerantName = cAlphaArgs(4); - if (state.dataFluidProps->GetInput) { - EnergyPlus::FluidProperties::GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - if (Util::FindItemInList(thisVrfFluidCtrlHR.RefrigerantName, state.dataFluidProps->RefrigData, state.dataFluidProps->NumOfRefrigerants) == + if (Util::FindItemInList(thisVrfFluidCtrlHR.RefrigerantName, state.dataFluid->RefrigData, state.dataFluid->NumOfRefrigerants) == 0) { ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrlHR.Name); ShowContinueError(state, "Illegal " + cAlphaFieldNames(4) + " = " + cAlphaArgs(4)); @@ -4300,7 +4292,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) if (thisVrfTU.SuppHeatCoilFluidMaxFlow > 0.0) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); thisVrfTU.SuppHeatCoilFluidMaxFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisVrfTU.SuppHeatCoilIndex, errFlag) * SteamDensity; } @@ -5527,7 +5519,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool using DataSizing::AutoSize; using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using ScheduleManager::GetCurrentScheduleValue; @@ -5697,7 +5689,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow * SteamDensity; } @@ -6329,7 +6321,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -8915,13 +8907,13 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) if (this->WaterCondVolFlowRate == DataSizing::AutoSize) { if (this->SourcePlantLoc.loopNum > 0) PltSizCondNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (PltSizCondNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -8937,7 +8929,7 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) this->WaterCondVolFlowRate); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -11031,14 +11023,14 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // A new physics based VRF model applicable for Fluid Temperature Control. using Curve::CurveValue; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSpecificHeatGlycol; - using FluidProperties::GetSupHeatDensityRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSpecificHeatGlycol; + using Fluid::GetSupHeatDensityRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; + using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; using PlantUtilities::SetComponentFlowRate; @@ -11223,10 +11215,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); RefMinPe = GetSatPressureRefrig(state, this->RefrigerantName, RefMinTe, RefrigerantIndex, RoutineName); RefMinPe = GetSatPressureRefrig(state, this->RefrigerantName, RefMinTe, RefrigerantIndex, RoutineName); - RefTLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowTempValue; // High Temperature Value for Ps (max in tables) - RefTHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) + RefTLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowTempValue; // High Temperature Value for Ps (max in tables) + RefTHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) // sum loads on TU coils for (NumTU = 1; NumTU <= NumTUInList; ++NumTU) { @@ -13485,11 +13477,11 @@ Real64 VRFCondenserEquipment::VRFOU_CapModFactor( // METHODOLOGY EMPLOYED: // This is part of the VRF-FluidTCtrl Model. - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSupHeatDensityRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSupHeatDensityRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; int RefrigerantIndex; // Index of the refrigerant [-] Real64 C_cap_density; // Compressor capacity modification algorithm_modified flow rate [-] @@ -13562,10 +13554,10 @@ void VRFCondenserEquipment::VRFOU_TeModification( // METHODOLOGY EMPLOYED: // This is part of the VRF-FluidTCtrl Model. - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; int CoolCoilIndex; // index to cooling coil in terminal unit int NumTUInList; // number of terminal units is list @@ -13592,8 +13584,8 @@ void VRFCondenserEquipment::VRFOU_TeModification( // variable initializations TUListNum = this->ZoneTUListPtr; RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; // Initialization of Te iterations (Label11) @@ -13700,9 +13692,9 @@ void VRFCondenserEquipment::VRFOU_CompSpd( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSupHeatTempRefrig; // Locals // SUBROUTINE ARGUMENT DEFINITIONS: @@ -13732,8 +13724,8 @@ void VRFCondenserEquipment::VRFOU_CompSpd( TUListNum = this->ZoneTUListPtr; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // variable initializations: compressor NumOfCompSpdInput = this->CompressorSpeed.size(); @@ -13859,9 +13851,9 @@ void VRFCondenserEquipment::VRFOU_CompCap( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSupHeatTempRefrig; int CounterCompSpdTemp; // Index for the compressor speed level[-] int CompSpdLB; // index for Compressor speed low bound [-] @@ -13886,8 +13878,8 @@ void VRFCondenserEquipment::VRFOU_CompCap( TUListNum = this->ZoneTUListPtr; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // variable initializations: compressor NumOfCompSpdInput = this->CompressorSpeed.size(); @@ -13981,12 +13973,12 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; + using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; int CounterCompSpdTemp; // Index for the compressor speed level[-] @@ -14044,8 +14036,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, TUListNum = this->ZoneTUListPtr; RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; Modifi_SH = Pipe_T_comp_in - T_suction; @@ -14330,12 +14322,12 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; + using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; int CounterCompSpdTemp; // Index for the compressor speed level[-] @@ -14375,8 +14367,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( TUListNum = this->ZoneTUListPtr; RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; // Calculate capacity modification factor @@ -14538,10 +14530,10 @@ void VRFCondenserEquipment::VRFHR_OU_HR_Mode(EnergyPlusData &state, // METHODOLOGY EMPLOYED: // This is part of the physics based VRF model applicable for Fluid Temperature Control. - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatPressureRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatPressureRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; using General::SolveRoot; Real64 constexpr ErrorTol(0.1); // tolerance for RegulaFalsi iterations @@ -14579,8 +14571,8 @@ void VRFCondenserEquipment::VRFHR_OU_HR_Mode(EnergyPlusData &state, // Initializations: component index RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; + RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // **Q_OU: HR mode determination // HRMode-1. Cooling Only @@ -14977,8 +14969,8 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( // METHODOLOGY EMPLOYED: // Use a physics based piping loss model. - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSupHeatDensityRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSupHeatDensityRefrig; using General::SolveRoot; int TUListNum; // index to TU List @@ -15016,8 +15008,8 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( // Refrigerant data RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - Real64 RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - Real64 RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) + Real64 RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) + Real64 RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) // Calculate Pipe_T_room Pipe_T_room = 0; @@ -15124,11 +15116,11 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( // METHODOLOGY EMPLOYED: // Use a physics based piping loss model. - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatTemperatureRefrig; - using FluidProperties::GetSupHeatDensityRefrig; - using FluidProperties::GetSupHeatEnthalpyRefrig; - using FluidProperties::GetSupHeatTempRefrig; + using Fluid::FindRefrigerant; + using Fluid::GetSatTemperatureRefrig; + using Fluid::GetSupHeatDensityRefrig; + using Fluid::GetSupHeatEnthalpyRefrig; + using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; int TUListNum; // index to TU List @@ -15167,9 +15159,9 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( // Refrigerant data RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - Real64 RefTHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) - Real64 RefPLow = state.dataFluidProps->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - Real64 RefPHigh = state.dataFluidProps->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) + Real64 RefTHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) + Real64 RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) + Real64 RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) Real64 RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); // Perform iteration to calculate Pipe_T_IU_in, given P and h diff --git a/src/EnergyPlus/HWBaseboardRadiator.cc b/src/EnergyPlus/HWBaseboardRadiator.cc index c6ff41bfedc..d3d6f57df9e 100644 --- a/src/EnergyPlus/HWBaseboardRadiator.cc +++ b/src/EnergyPlus/HWBaseboardRadiator.cc @@ -880,7 +880,7 @@ namespace HWBaseboardRadiator { // Initialize WaterInletNode = HWBaseboard.WaterInletNode; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidIndex, @@ -892,7 +892,7 @@ namespace HWBaseboardRadiator { state.dataLoopNodes->Node(WaterInletNode).Temp = 60.0; - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(WaterInletNode).Temp, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1068,12 +1068,12 @@ namespace HWBaseboardRadiator { CheckZoneSizing(state, cCMO_BBRadiator_Water, hWBaseboard.Name); DesCoilLoad = RatedCapacityDes; if (DesCoilLoad >= HVAC::SmallLoad) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, RoutineName); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1120,7 +1120,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; } else if (hWBaseboard.RatedCapacity == DataSizing::AutoSize || hWBaseboard.RatedCapacity == 0.0) { DesCoilLoad = RatedCapacityDes; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1132,7 +1132,7 @@ namespace HWBaseboardRadiator { // Air mass flow rate is obtained from the following linear equation // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, hWBaseboard.WaterTempAvg, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1188,7 +1188,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, hWBaseboard.WaterTempAvg, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1293,7 +1293,7 @@ namespace HWBaseboardRadiator { // Calculate air mass flow rate AirMassFlowRate = hWBaseboard.AirMassFlowRateStd * (WaterMassFlowRate / hWBaseboard.WaterMassFlowRateMax); CapacitanceAir = Psychrometrics::PsyCpAirFnW(hWBaseboard.AirInletHumRat) * AirMassFlowRate; - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, WaterInletTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc index 273cb0b0aeb..7dfb18e22e5 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc @@ -359,7 +359,7 @@ void GetGshpInput(EnergyPlusData &state) ShowFatalError(state, "Errors Found in getting Gshp input"); } - state.dataHPWaterToWaterClg->GSHPRefrigIndex = FluidProperties::FindRefrigerant(state, GSHPRefrigerant); + state.dataHPWaterToWaterClg->GSHPRefrigIndex = Fluid::FindRefrigerant(state, GSHPRefrigerant); if (state.dataHPWaterToWaterClg->GSHPRefrigIndex == 0) { ShowFatalError(state, format("Refrigerant for {} not found, should have been={}", ModuleCompName, GSHPRefrigerant)); ShowFatalError(state, format("FluidProperties:* objects for {} must be included in the idf file.", GSHPRefrigerant)); @@ -489,7 +489,7 @@ void GshpPeCoolingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -498,7 +498,7 @@ void GshpPeCoolingSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -660,13 +660,13 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) initialQLoad = 0.0; IterationCount = 0; - CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, + CpSourceSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, this->SourceSideWaterInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, + CpLoadSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, this->LoadSideWaterInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -689,9 +689,9 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) this->SourceSideWaterInletTemp + initialQSource / (SourceSideEffect * CpSourceSide * this->SourceSideWaterMassFlowRate); // Determine the evaporating and condensing pressures - SourceSidePressure = FluidProperties::GetSatPressureRefrig( + SourceSidePressure = Fluid::GetSatPressureRefrig( state, GSHPRefrigerant, SourceSideRefridgTemp, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineName); - LoadSidePressure = FluidProperties::GetSatPressureRefrig( + LoadSidePressure = Fluid::GetSatPressureRefrig( state, GSHPRefrigerant, LoadSideRefridgTemp, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineName); if (SourceSidePressure < this->LowPressCutoff) { @@ -738,11 +738,11 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the Source Side Outlet Enthalpy qual = 1.0; - LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( + LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, GSHPRefrigerant, LoadSideRefridgTemp, qual, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameLoadSideRefridgTemp); qual = 0.0; - SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( + SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, GSHPRefrigerant, SourceSideRefridgTemp, qual, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameSourceSideRefridgTemp); // Determine Load Side Outlet Enthalpy @@ -750,7 +750,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) CompressInletTemp = LoadSideRefridgTemp + this->SuperheatTemp; // Determine the enathalpy of the super heated fluid at Source Side outlet - SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig( + SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompressInletTemp, LoadSidePressure, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompressInletTemp); // Determining the suction state of the fluid from inlet state involves interation @@ -759,7 +759,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached // this routine was reenginerred from HVACsim + takes pressure in Pascals, tolrance, refrgerant # R22 =6 - CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( + CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( state, GSHPRefrigerant, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameSuctionPr); T110 = CompSuctionSatTemp; @@ -769,7 +769,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) while (true) { CompSuctionTemp = 0.5 * (T110 + T111); - CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig( + CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); if (std::abs(CompSuctionEnth - SuperHeatEnth) / SuperHeatEnth < 0.0001) { @@ -785,7 +785,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) LOOP_exit:; // Determine the Mass flow rate of refrigerant - CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig( + CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); MassRef = this->CompPistonDisp * CompSuctionDensity * (1 + this->CompClearanceFactor - this->CompClearanceFactor * std::pow(DischargePr / SuctionPr, 1 / gamma)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc index c50b41b9f1e..e3428d2a5cb 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc @@ -349,7 +349,7 @@ void GetGshpInput(EnergyPlusData &state) ShowFatalError(state, format("Errors Found in getting {} Input", ModuleCompNameUC)); } - state.dataHPWaterToWaterHtg->GSHPRefrigIndex = FluidProperties::FindRefrigerant(state, GSHPRefrigerant); + state.dataHPWaterToWaterHtg->GSHPRefrigIndex = Fluid::FindRefrigerant(state, GSHPRefrigerant); if (state.dataHPWaterToWaterHtg->GSHPRefrigIndex == 0) { ShowFatalError(state, format("Refrigerant for {} not found, should have been={}", ModuleCompName, GSHPRefrigerant)); } @@ -479,7 +479,7 @@ void GshpPeHeatingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -488,7 +488,7 @@ void GshpPeHeatingSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -613,13 +613,13 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) Real64 initialQLoad = 0.0; int IterationCount = 0; - Real64 CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpSourceSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, this->SourceSideWaterInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpLoadSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, this->LoadSideWaterInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -640,9 +640,9 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) Real64 LoadSideTemp = this->LoadSideWaterInletTemp + initialQLoad / (LoadSideEffect * CpLoadSide * this->LoadSideWaterMassFlowRate); // Determine the evaporating and condensing pressures - Real64 SourceSidePressure = FluidProperties::GetSatPressureRefrig( + Real64 SourceSidePressure = Fluid::GetSatPressureRefrig( state, GSHPRefrigerant, SourceSideTemp, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSourceSideTemp); - Real64 LoadSidePressure = FluidProperties::GetSatPressureRefrig( + Real64 LoadSidePressure = Fluid::GetSatPressureRefrig( state, GSHPRefrigerant, LoadSideTemp, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameLoadSideTemp); // check cutoff pressures @@ -682,18 +682,18 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the Source Side Outlet Enthalpy Real64 qualOne = 1.0; - Real64 SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( + Real64 SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, GSHPRefrigerant, SourceSideTemp, qualOne, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSourceSideTemp); // Determine Load Side Outlet Enthalpy Real64 qualZero = 0.0; - Real64 LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( + Real64 LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, GSHPRefrigerant, LoadSideTemp, qualZero, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameLoadSideTemp); // Determine superheated temperature of the Source Side outlet/compressor inlet Real64 CompressInletTemp = SourceSideTemp + this->SuperheatTemp; // Determine the enathalpy of the super heated fluid at Source Side outlet - Real64 SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, + Real64 SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, GSHPRefrigerant, CompressInletTemp, SourceSidePressure, @@ -705,7 +705,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the saturated temp at suction pressure, shoot out into the superheated region find the enthalpy // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached - CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( + CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( state, GSHPRefrigerant, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSuctionPr); Real64 T110 = CompSuctionSatTemp; @@ -716,7 +716,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) while (true) { CompSuctionTemp = 0.5 * (T110 + T111); - CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig( + CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); if (std::abs(CompSuctionEnth - SuperHeatEnth) / SuperHeatEnth < 0.0001) { break; @@ -730,7 +730,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) } // Determine the Mass flow rate of refrigerant - CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig( + CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); Real64 MassRef = this->CompPistonDisp * CompSuctionDensity * (1.0 + this->CompClearanceFactor - this->CompClearanceFactor * std::pow(DischargePr / SuctionPr, 1.0 / gamma)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc index ec365e8c315..ba04b7dfaf5 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc @@ -729,26 +729,26 @@ void GshpSpecs::InitWatertoWaterHP(EnergyPlusData &state, this->MustRun = true; if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFHeating) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowHeat * rho; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); this->SourceSideDesignMassFlow = this->RatedSourceVolFlowHeat * rho; } else if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFCooling) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowCool * rho; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -881,12 +881,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) // store flow rate right away regardless of PlantFirstSizesOkayToFinalize so that data are available this->RatedLoadVolFlowCool = tmpLoadSideVolFlowRate; } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -894,12 +894,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) tmpCoolingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else if (this->companionIdentified && this->RatedLoadVolFlowHeat > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1069,12 +1069,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) if (!this->ratedLoadVolFlowCoolWasAutoSized) tmpLoadSideVolFlowRate = this->RatedLoadVolFlowCool; int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1237,12 +1237,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) // PlantFirstSizesOkayToFinalize is true this->RatedLoadVolFlowHeat = tmpLoadSideVolFlowRate; } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1250,12 +1250,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) tmpHeatingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else if (this->companionIdentified && this->RatedLoadVolFlowCool > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowCool; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1424,12 +1424,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) if (!this->ratedLoadVolFlowHeatWasAutoSized) tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1622,13 +1622,13 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My return; } - rhoLoadSide = FluidProperties::GetDensityGlycol(state, + rhoLoadSide = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - rhoSourceSide = FluidProperties::GetDensityGlycol(state, + rhoSourceSide = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1697,13 +1697,13 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, + CpLoadSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, + CpSourceSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1786,13 +1786,13 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My if (!this->MustRun) { return; } - rhoLoadSide = FluidProperties::GetDensityGlycol(state, + rhoLoadSide = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - rhoSourceSide = FluidProperties::GetDensityGlycol(state, + rhoSourceSide = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1860,13 +1860,13 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, + CpLoadSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, + CpSourceSide = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Humidifiers.cc b/src/EnergyPlus/Humidifiers.cc index 640fe85053c..e6839367170 100644 --- a/src/EnergyPlus/Humidifiers.cc +++ b/src/EnergyPlus/Humidifiers.cc @@ -721,10 +721,10 @@ namespace Humidifiers { // Using/Aliasing using DataSizing::AutoSize; - using FluidProperties::FindGlycol; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::FindGlycol; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyRhoAirFnPbTdbW; using Psychrometrics::RhoH2O; @@ -1164,10 +1164,10 @@ namespace Humidifiers { // Using/Aliasing using Curve::CurveValue; - using FluidProperties::FindGlycol; - using FluidProperties::FindRefrigerant; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::FindGlycol; + using Fluid::FindRefrigerant; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyTdbFnHW; using Psychrometrics::PsyWFnTdbRhPb; diff --git a/src/EnergyPlus/ICEngineElectricGenerator.cc b/src/EnergyPlus/ICEngineElectricGenerator.cc index 0a69998a723..ba63156289e 100644 --- a/src/EnergyPlus/ICEngineElectricGenerator.cc +++ b/src/EnergyPlus/ICEngineElectricGenerator.cc @@ -748,7 +748,7 @@ namespace ICEngineElectricGenerator { HRecRatio = 1.0; Real64 HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 HeatRecCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -876,7 +876,7 @@ namespace ICEngineElectricGenerator { if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/IceThermalStorage.cc b/src/EnergyPlus/IceThermalStorage.cc index 7b1aed106ae..ab0392f0cd2 100644 --- a/src/EnergyPlus/IceThermalStorage.cc +++ b/src/EnergyPlus/IceThermalStorage.cc @@ -224,7 +224,7 @@ namespace IceThermalStorage { } Real64 DemandMdot = this->DesignMassFlowRate; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TempIn, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -361,7 +361,7 @@ namespace IceThermalStorage { } // Calculate the current load on the ice storage unit - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TempIn, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1688,7 +1688,7 @@ namespace IceThermalStorage { //---------------------------- int loopNum = this->plantLoc.loopNum; - Real64 CpFluid = FluidProperties::GetDensityGlycol(state, + Real64 CpFluid = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(loopNum).FluidName, state.dataLoopNodes->Node(this->PltInletNodeNum).Temp, state.dataPlnt->PlantLoop(loopNum).FluidIndex, diff --git a/src/EnergyPlus/LowTempRadiantSystem.cc b/src/EnergyPlus/LowTempRadiantSystem.cc index 4be3eac4787..3a7834158af 100644 --- a/src/EnergyPlus/LowTempRadiantSystem.cc +++ b/src/EnergyPlus/LowTempRadiantSystem.cc @@ -272,7 +272,7 @@ namespace LowTempRadiantSystem { using DataSizing::FractionOfAutosizedCoolingCapacity; using DataSizing::FractionOfAutosizedHeatingCapacity; using DataSizing::HeatingDesignCapacity; - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; @@ -1904,7 +1904,7 @@ namespace LowTempRadiantSystem { using DataSizing::AutoSize; using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -2633,8 +2633,8 @@ namespace LowTempRadiantSystem { // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using HVAC::AutoCalculateSizing; using HVAC::CoolingCapacitySizing; using HVAC::HeatingCapacitySizing; @@ -4181,7 +4181,7 @@ namespace LowTempRadiantSystem { // Using/Aliasing using DataHeatBalance::ZoneData; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using HVAC::SmallLoad; using PlantUtilities::SetComponentFlowRate; using ScheduleManager::GetCurrentScheduleValue; @@ -4691,7 +4691,7 @@ namespace LowTempRadiantSystem { auto &Zone = state.dataHeatBal->Zone; // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // SUBROUTINE PARAMETER DEFINITIONS: @@ -5328,7 +5328,7 @@ namespace LowTempRadiantSystem { { // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; using PlantUtilities::SetComponentFlowRate; @@ -5414,7 +5414,7 @@ namespace LowTempRadiantSystem { { // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; using PlantUtilities::SetComponentFlowRate; @@ -5645,7 +5645,7 @@ namespace LowTempRadiantSystem { // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; // Return value Real64 calculateHXEffectivenessTerm; @@ -5980,7 +5980,7 @@ namespace LowTempRadiantSystem { // Using/Aliasing Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; constexpr std::string_view routineName("ReportConstantFlowSystem"); Real64 cpFluid; // Specific heat of the fluid in the radiant system diff --git a/src/EnergyPlus/MicroCHPElectricGenerator.cc b/src/EnergyPlus/MicroCHPElectricGenerator.cc index 409b3df0f3c..73aeffcbd11 100644 --- a/src/EnergyPlus/MicroCHPElectricGenerator.cc +++ b/src/EnergyPlus/MicroCHPElectricGenerator.cc @@ -696,7 +696,7 @@ void MicroCHPDataStruct::onInitLoopEquip(EnergyPlusData &state, const EnergyPlus { static constexpr std::string_view RoutineName("MicroCHPDataStruct::onInitLoopEquip"); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->PlantInletNodeID).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1165,7 +1165,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s Teng = FuncDetermineEngineTemp( TcwOut, this->A42Model.MCeng, this->A42Model.UAhx, this->A42Model.UAskin, thisAmbientTemp, Qgenss, this->A42Model.TengLast, dt); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1382,7 +1382,7 @@ void MicroCHPDataStruct::CalcUpdateHeatRecovery(EnergyPlusData &state) const state.dataLoopNodes->Node(this->PlantOutletNodeID).Temp = this->A42Model.TcwOut; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, this->A42Model.TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1417,7 +1417,7 @@ void MicroCHPDataStruct::UpdateMicroCHPGeneratorRecords(EnergyPlusData &state) / this->A42Model.ACEnergyGen = this->A42Model.Pnet * state.dataHVACGlobal->TimeStepSysSec; // energy produced (J) this->A42Model.QdotHX = this->A42Model.UAhx * (this->A42Model.Teng - this->A42Model.TcwOut); // heat recovered rate (W) - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, this->A42Model.TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/MicroturbineElectricGenerator.cc b/src/EnergyPlus/MicroturbineElectricGenerator.cc index 7fec013cf98..bcff2b46c84 100644 --- a/src/EnergyPlus/MicroturbineElectricGenerator.cc +++ b/src/EnergyPlus/MicroturbineElectricGenerator.cc @@ -1251,7 +1251,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, if (this->HeatRecActive) { HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, + HeatRecCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1585,7 +1585,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, // Calculate heat recovery rate modifier curve output (function of water [volumetric] flow rate) if (this->HeatRecRateFWaterFlowCurveNum > 0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1958,7 +1958,7 @@ void MTGeneratorSpecs::oneTimeInit(EnergyPlusData &state) if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/NodeInputManager.cc b/src/EnergyPlus/NodeInputManager.cc index 5f67b91ad73..e60b130c2e9 100644 --- a/src/EnergyPlus/NodeInputManager.cc +++ b/src/EnergyPlus/NodeInputManager.cc @@ -967,10 +967,10 @@ void CalcMoreNodeInfo(EnergyPlusData &state) // stored in MoreNodeInfo. // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::CPCW; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; @@ -1031,7 +1031,7 @@ void CalcMoreNodeInfo(EnergyPlusData &state) for (int iNode = 1; iNode <= state.dataLoopNodes->NumOfNodes; ++iNode) { nodeReportingStrings.push_back(std::string(NodeReportingCalc + state.dataLoopNodes->NodeID(iNode))); - nodeFluidNames.push_back(FluidProperties::GetGlycolNameByIndex(state, state.dataLoopNodes->Node(iNode).FluidIndex)); + nodeFluidNames.push_back(Fluid::GetGlycolNameByIndex(state, state.dataLoopNodes->Node(iNode).FluidIndex)); for (auto const *reqVar : state.dataOutputProcessor->reqVars) { if (Util::SameString(reqVar->key, state.dataLoopNodes->NodeID(iNode)) || reqVar->key.empty()) { @@ -1143,7 +1143,7 @@ void CalcMoreNodeInfo(EnergyPlusData &state) } else if (state.dataLoopNodes->Node(iNode).FluidType == DataLoopNode::NodeFluidType::Water) { if (!((state.dataLoopNodes->Node(iNode).FluidIndex > 0) && - (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluidProps->NumOfGlycols))) { + (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluid->NumOfGlycols))) { rho = RhoWaterStdInit; rhoStd = RhoWaterStdInit; Cp = CPCW(state.dataLoopNodes->Node(iNode).Temp); diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index 2dcc30e4a61..9a59cb708d1 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -116,7 +116,6 @@ namespace OutdoorAirUnit { using HVAC::SmallMassFlow; using namespace ScheduleManager; using namespace Psychrometrics; - using namespace FluidProperties; // component types addressed by this module constexpr static std::string_view ZoneHVACOAUnit = {"ZoneHVAC:OutdoorAirUnit"}; @@ -218,7 +217,7 @@ namespace OutdoorAirUnit { // Using/Aliasing using BranchNodeConnections::SetUpCompSets; using BranchNodeConnections::TestCompSet; - using FluidProperties::FindRefrigerant; + using Fluid::FindRefrigerant; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; using SteamCoils::GetCoilAirInletNode; @@ -1116,7 +1115,7 @@ namespace OutdoorAirUnit { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1286,7 +1285,7 @@ namespace OutdoorAirUnit { thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow = GetCoilMaxSteamFlowRate(state, thisOutAirUnit.OAEquip(compLoop).ComponentIndex, errFlag); Real64 const rho = - GetSatDensityRefrig(state, + Fluid::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidName, Constant::SteamInitConvTemp, 1.0, diff --git a/src/EnergyPlus/OutsideEnergySources.cc b/src/EnergyPlus/OutsideEnergySources.cc index 452a0703452..bc45d174aa0 100644 --- a/src/EnergyPlus/OutsideEnergySources.cc +++ b/src/EnergyPlus/OutsideEnergySources.cc @@ -371,19 +371,19 @@ void OutsideEnergySourceSpecs::size(EnergyPlusData &state) if (this->EnergyType == DataPlant::PlantEquipmentType::PurchChilledWater || this->EnergyType == DataPlant::PlantEquipmentType::PurchHotWater) { Real64 const rho = - FluidProperties::GetDensityGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); + Fluid::GetDensityGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); Real64 const Cp = - FluidProperties::GetSpecificHeatGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); + Fluid::GetSpecificHeatGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); NomCapDes = Cp * rho * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate; } else { // this->EnergyType == DataPlant::TypeOf_PurchSteam - Real64 const tempSteam = FluidProperties::GetSatTemperatureRefrig( + Real64 const tempSteam = Fluid::GetSatTemperatureRefrig( state, loop.FluidName, state.dataEnvrn->StdBaroPress, loop.FluidIndex, format("Size {}", typeName)); Real64 const rhoSteam = - FluidProperties::GetSatDensityRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); + Fluid::GetSatDensityRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const EnthSteamDry = - FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); + Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const EnthSteamWet = - FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 0.0, loop.FluidIndex, format("Size {}", typeName)); + Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 0.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const LatentHeatSteam = EnthSteamDry - EnthSteamWet; NomCapDes = rhoSteam * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate * LatentHeatSteam; } @@ -474,7 +474,7 @@ void OutsideEnergySourceSpecs::calculate(EnergyPlusData &state, bool runFlag, Re if ((this->MassFlowRate > 0.0) && runFlag) { if (this->EnergyType == DataPlant::PlantEquipmentType::PurchChilledWater || this->EnergyType == DataPlant::PlantEquipmentType::PurchHotWater) { - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 const Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); this->OutletTemp = (MyLoad + this->MassFlowRate * Cp * this->InletTemp) / (this->MassFlowRate * Cp); // apply loop limits on temperature result to keep in check @@ -489,11 +489,11 @@ void OutsideEnergySourceSpecs::calculate(EnergyPlusData &state, bool runFlag, Re } else if (this->EnergyType == DataPlant::PlantEquipmentType::PurchSteam) { // determine mass flow rate based on inlet temp, saturate temp at // atmospheric pressure, Cp of inlet condensate, and MyLoad Real64 SatTempAtmPress = - FluidProperties::GetSatTemperatureRefrig(state, loop.FluidName, DataEnvironment::StdPressureSeaLevel, loop.FluidIndex, RoutineName); - Real64 CpCondensate = FluidProperties::GetSpecificHeatGlycol(state, loop.FluidName, this->InletTemp, loop.FluidIndex, RoutineName); + Fluid::GetSatTemperatureRefrig(state, loop.FluidName, DataEnvironment::StdPressureSeaLevel, loop.FluidIndex, RoutineName); + Real64 CpCondensate = Fluid::GetSpecificHeatGlycol(state, loop.FluidName, this->InletTemp, loop.FluidIndex, RoutineName); Real64 deltaTsensible = SatTempAtmPress - this->InletTemp; - Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 1.0, loop.FluidIndex, RoutineName); - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 0.0, loop.FluidIndex, RoutineName); + Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 1.0, loop.FluidIndex, RoutineName); + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 0.0, loop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; this->MassFlowRate = MyLoad / (LatentHeatSteam + (CpCondensate * deltaTsensible)); PlantUtilities::SetComponentFlowRate(state, this->MassFlowRate, this->InletNodeNum, this->OutletNodeNum, this->plantLoc); diff --git a/src/EnergyPlus/PackagedThermalStorageCoil.cc b/src/EnergyPlus/PackagedThermalStorageCoil.cc index c889f61c53c..94567c790e4 100644 --- a/src/EnergyPlus/PackagedThermalStorageCoil.cc +++ b/src/EnergyPlus/PackagedThermalStorageCoil.cc @@ -198,10 +198,10 @@ void GetTESCoilInput(EnergyPlusData &state) // Using/Aliasing using BranchNodeConnections::TestCompSet; using DataZoneEquipment::FindControlledZoneIndexFromSystemNodeNumberForZone; - using FluidProperties::CheckFluidPropertyName; - using FluidProperties::FindGlycol; - using FluidProperties::GetFluidDensityTemperatureLimits; - using FluidProperties::GetFluidSpecificHeatTemperatureLimits; + using Fluid::CheckFluidPropertyName; + using Fluid::FindGlycol; + using Fluid::GetFluidDensityTemperatureLimits; + using Fluid::GetFluidSpecificHeatTemperatureLimits; using GlobalNames::VerifyUniqueCoilName; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; @@ -2145,8 +2145,8 @@ void SizeTESCoil(EnergyPlusData &state, int &TESCoilNum) // Using/Aliasing using namespace DataSizing; using namespace OutputReportPredefined; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("SizeTESCoil "); @@ -2771,8 +2771,8 @@ void CalcTESCoilCoolingAndChargeMode(EnergyPlusData &state, // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3181,8 +3181,8 @@ void CalcTESCoilCoolingAndDischargeMode(EnergyPlusData &state, // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3528,8 +3528,8 @@ void CalcTESCoilChargeOnlyMode(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("CalcTESCoilChargeOnlyMode"); @@ -3692,8 +3692,8 @@ void CalcTESCoilDischargeOnlyMode(EnergyPlusData &state, int const TESCoilNum, R // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3994,8 +3994,8 @@ void CalcTESWaterStorageTank(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using WaterThermalTanks::WaterThermalTankData; auto &thisTESCoil = state.dataPackagedThermalStorageCoil->TESCoil(TESCoilNum); @@ -4104,7 +4104,7 @@ void CalcTESIceStorageTank(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: constexpr Real64 FreezingTemp(0.0); // zero degrees C diff --git a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc index 1dcca089a10..eda0d2ed155 100644 --- a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc +++ b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc @@ -701,7 +701,7 @@ namespace PhotovoltaicThermalCollectors { switch (this->WorkingFluidType) { case WorkingFluidEnum::LIQUID: { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->WPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->WPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PipeHeatTransfer.cc b/src/EnergyPlus/PipeHeatTransfer.cc index f8761f3275c..57b34133931 100644 --- a/src/EnergyPlus/PipeHeatTransfer.cc +++ b/src/EnergyPlus/PipeHeatTransfer.cc @@ -942,8 +942,8 @@ void PipeHTData::InitPipesHeatTransfer(EnergyPlusData &state, bool const FirstHV // Using/Aliasing Real64 SysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using ScheduleManager::GetCurrentScheduleValue; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1713,8 +1713,8 @@ Real64 PipeHTData::CalcPipeHeatTransCoef(EnergyPlusData &state, // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using FluidProperties::GetConductivityGlycol; - using FluidProperties::GetViscosityGlycol; + using Fluid::GetConductivityGlycol; + using Fluid::GetViscosityGlycol; // Return value Real64 CalcPipeHeatTransCoef; diff --git a/src/EnergyPlus/Plant/EquipAndOperations.cc b/src/EnergyPlus/Plant/EquipAndOperations.cc index 96d2871e845..80df453c7b4 100644 --- a/src/EnergyPlus/Plant/EquipAndOperations.cc +++ b/src/EnergyPlus/Plant/EquipAndOperations.cc @@ -883,7 +883,7 @@ namespace DataPlant { // Calculate load on primary chilled water loop and store in PrimaryPlantCoolingLoad Real64 CW_RetMdot = state.dataLoopNodes->Node(this->PlantOps.PrimaryChWLoopSupInletNode).MassFlowRate; - Real64 const CpCW = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpCW = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryChWLoopIndex).FluidName, state.dataLoopNodes->Node(this->PlantOps.PrimaryChWLoopSupInletNode).Temp, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryChWLoopIndex).FluidIndex, @@ -899,7 +899,7 @@ namespace DataPlant { // int HWSupInletNode = this->PlantOps.PrimaryHWLoopSupInletNode; // state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).LoopSide(DataPlant::LoopSideLocation::Supply).Branch(1).NodeNumIn; Real64 HW_RetMdot = state.dataLoopNodes->Node(this->PlantOps.PrimaryHWLoopSupInletNode).MassFlowRate; - Real64 const CpHW = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpHW = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).FluidName, state.dataLoopNodes->Node(this->PlantOps.PrimaryHWLoopSupInletNode).Temp, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).FluidIndex, @@ -1372,7 +1372,7 @@ namespace DataPlant { // step 2. calculate the loads to adjust the // returns to hit the associated setpoints at their current mass flow Real64 const CpCW = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DedicatedHR_HeatingPLHP.sourceSidePlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(inletChWReturnNodeNum).Temp, state.dataPlnt->PlantLoop(this->DedicatedHR_HeatingPLHP.sourceSidePlantLoc.loopNum).FluidIndex, @@ -1381,7 +1381,7 @@ namespace DataPlant { CW_RetMdot * CpCW * (this->Setpoint.SecCW - state.dataLoopNodes->Node(inletChWReturnNodeNum).Temp); // power = Mdot Cp Delta T, cooling load is negative Real64 const CpHW = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DedicatedHR_CoolingPLHP.sourceSidePlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(inletHWReturnNodeNum).Temp, state.dataPlnt->PlantLoop(this->DedicatedHR_CoolingPLHP.sourceSidePlantLoc.loopNum).FluidIndex, @@ -1605,7 +1605,7 @@ namespace DataPlant { Real64 Mdot = state.dataLoopNodes->Node(inletBoilerNodeNum).MassFlowRate; Real64 const CpHW = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantBoilerComps(BoilerNum).loopNum).FluidName, Tin, state.dataPlnt->PlantLoop(this->PlantBoilerComps(BoilerNum).loopNum).FluidIndex, diff --git a/src/EnergyPlus/Plant/Loop.cc b/src/EnergyPlus/Plant/Loop.cc index e897248a8dd..167eaeeac85 100644 --- a/src/EnergyPlus/Plant/Loop.cc +++ b/src/EnergyPlus/Plant/Loop.cc @@ -104,8 +104,6 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) // Using/Aliasing using DataPlant::LoopDemandTol; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("PlantLoopSolver::EvaluateLoopSetPointLoad"); @@ -135,7 +133,7 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) if (this->FluidType == DataLoopNode::NodeFluidType::Water) { - Cp = GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); switch (this->LoopDemandCalcScheme) { case DataPlant::LoopDemandCalcScheme::SingleSetPoint: { @@ -179,7 +177,7 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) } else if (this->FluidType == DataLoopNode::NodeFluidType::Steam) { - Cp = GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); switch (this->LoopDemandCalcScheme) { case DataPlant::LoopDemandCalcScheme::SingleSetPoint: { @@ -190,8 +188,8 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) // Calculate the delta temperature DeltaTemp = LoopSetPointTemperature - TargetTemp; - EnthalpySteamSatVapor = GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); - EnthalpySteamSatLiquid = GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatVapor = Fluid::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatLiquid = Fluid::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); LatentHeatSteam = EnthalpySteamSatVapor - EnthalpySteamSatLiquid; diff --git a/src/EnergyPlus/Plant/LoopSide.cc b/src/EnergyPlus/Plant/LoopSide.cc index c30fc3ceefa..cd3713c3c08 100644 --- a/src/EnergyPlus/Plant/LoopSide.cc +++ b/src/EnergyPlus/Plant/LoopSide.cc @@ -738,7 +738,7 @@ namespace DataPlant { if (thisPlantLoop.FluidType == DataLoopNode::NodeFluidType::Water) { Real64 Cp = - FluidProperties::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); + Fluid::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); { @@ -811,7 +811,7 @@ namespace DataPlant { } else if (thisPlantLoop.FluidType == DataLoopNode::NodeFluidType::Steam) { Real64 Cp = - FluidProperties::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); + Fluid::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); { @@ -824,9 +824,9 @@ namespace DataPlant { Real64 DeltaTemp = LoopSetPointTemperature - WeightedInletTemp; Real64 EnthalpySteamSatVapor = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 1.0, this->refrigIndex, RoutineNameAlt); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 1.0, this->refrigIndex, RoutineNameAlt); Real64 EnthalpySteamSatLiquid = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 0.0, this->refrigIndex, RoutineNameAlt); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 0.0, this->refrigIndex, RoutineNameAlt); Real64 LatentHeatSteam = EnthalpySteamSatVapor - EnthalpySteamSatLiquid; @@ -1945,9 +1945,6 @@ namespace DataPlant { // load range based: these components do not 'alter' the load, they reject the load // Therefore they are not included - // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; - // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("PlantLoopSolver::UpdateAnyLoopDemandAlterations"); @@ -2001,7 +1998,7 @@ namespace DataPlant { Real64 const InletTemp(state.dataLoopNodes->Node(InletNode).Temp); Real64 const OutletTemp(state.dataLoopNodes->Node(OutletNode).Temp); Real64 const AverageTemp((InletTemp + OutletTemp) / 2.0); - Real64 const ComponentCp(GetSpecificHeatGlycol(state, + Real64 const ComponentCp(Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index fca77e8877d..2ccb556362b 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -143,7 +143,6 @@ namespace EnergyPlus::PlantManager { using namespace DataPlant; using namespace DataBranchAirLoopPlant; using namespace DataLoopNode; -using namespace FluidProperties; static constexpr std::string_view fluidNameSteam("STEAM"); @@ -291,8 +290,6 @@ void GetPlantLoopData(EnergyPlusData &state) using NodeInputManager::GetOnlySingleNode; using namespace BranchInputManager; using DataSizing::AutoSize; - using FluidProperties::CheckFluidPropertyName; - using FluidProperties::FindGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("GetPlant/CondenserLoopData: "); @@ -386,17 +383,17 @@ void GetPlantLoopData(EnergyPlusData &state) } else if (Util::SameString(Alpha(2), "WATER")) { this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = Alpha(2); - this_loop.FluidIndex = FindGlycol(state, Alpha(2)); + this_loop.FluidIndex = Fluid::FindGlycol(state, Alpha(2)); } else if (Util::SameString(Alpha(2), "USERDEFINEDFLUIDTYPE")) { this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = Alpha(3); // check for valid fluid name - NumFluids = CheckFluidPropertyName(state, Alpha(3)); + NumFluids = Fluid::CheckFluidPropertyName(state, Alpha(3)); if (NumFluids == 0) { ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", missing fluid data for Plant loop."); ErrorsFound = true; } else { - this_loop.FluidIndex = FindGlycol(state, Alpha(3)); + this_loop.FluidIndex = Fluid::FindGlycol(state, Alpha(3)); if (this_loop.FluidIndex == 0) { ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", invalid glycol fluid data for Plant loop."); ErrorsFound = true; @@ -410,7 +407,7 @@ void GetPlantLoopData(EnergyPlusData &state) this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = "WATER"; - this_loop.FluidIndex = FindGlycol(state, "WATER"); + this_loop.FluidIndex = Fluid::FindGlycol(state, "WATER"); } this_loop.OperationScheme = Alpha(4); // Load the Plant Control Scheme Priority List @@ -2512,7 +2509,7 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).OutletNode.MassFlowRateHistory = 0.0; if (state.dataPlnt->PlantLoop(LoopNum).FluidType != DataLoopNode::NodeFluidType::Steam) { - Cp = GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LoopSetPointTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -2521,7 +2518,7 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) } // Use Min/Max flow rates to initialize loop if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - rho = GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LoopSetPointTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -2534,9 +2531,9 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { SteamTemp = 100.0; SteamDensity = - GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); LoopMaxMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MaxVolFlowRate * SteamDensity; - StartEnthalpy = GetSatEnthalpyRefrig( + StartEnthalpy = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, LoopSetPointTemp, 0.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); LoopMinMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate * SteamDensity; } @@ -2967,7 +2964,6 @@ void SizePlantLoop(EnergyPlusData &state, // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("SizePlantLoop"); @@ -3242,10 +3238,10 @@ void SizePlantLoop(EnergyPlusData &state, // should now have plant volume, calculate plant volume's mass for fluid type if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - FluidDensity = GetDensityGlycol( + FluidDensity = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); if (PlantSizNum > 0 && allocated(state.dataSize->PlantSizData)) { // method only works if sizing delta T is avaiable - Real64 cp = GetSpecificHeatGlycol(state, + Real64 cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -3255,7 +3251,7 @@ void SizePlantLoop(EnergyPlusData &state, state.dataSize->PlantSizData(PlantSizNum).DesCapacity = DesignPlantCapacity; // store it for later use in scaling } } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } @@ -3288,7 +3284,6 @@ void ResizePlantLoopLevelSizes(EnergyPlusData &state, int const LoopNum // Suppl // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("ResizePlantLoop"); @@ -3387,10 +3382,10 @@ void ResizePlantLoopLevelSizes(EnergyPlusData &state, int const LoopNum // Suppl // should now have plant volume, calculate plant volume's mass for fluid type if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - FluidDensity = GetDensityGlycol( + FluidDensity = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index 323da9bafe3..a698ab2be93 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -313,13 +313,13 @@ void WrapperSpecs::SizeWrapper(EnergyPlusData &state) // each individual chiller heater module is sized to be capable of supporting the total load on the wrapper if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpEvapVolFlowRate > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -414,13 +414,13 @@ void WrapperSpecs::SizeWrapper(EnergyPlusData &state) // each individual chiller heater module is sized to be capable of supporting the total load on the wrapper if (PltSizCondNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, RoutineName); // TODO: JM 2018-12-06 I wonder why Cp isn't calculated at the same temp as rho... - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, this->ChillerHeater(NumChillerHeater).TempRefCondInCooling, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, @@ -1685,7 +1685,7 @@ void WrapperSpecs::initialize(EnergyPlusData &state, this->GLHEVolFlowRate += this->ChillerHeater(ChillerHeaterNum).CondVolFlowRate; } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1899,17 +1899,17 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) // Calculate density ratios to adjust mass flow rates from initialized ones // Hot water temperature is known, but evaporator mass flow rates will be adjusted in the following "Do" loop - Real64 InitDensity = FluidProperties::GetDensityGlycol(state, + Real64 InitDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 EvapDensity = FluidProperties::GetDensityGlycol(state, + Real64 EvapDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CondDensity = FluidProperties::GetDensityGlycol(state, + Real64 CondDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2028,7 +2028,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) } // Calculate the specific heat of chilled water - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2165,7 +2165,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) } if (CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, @@ -2340,17 +2340,17 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Calculate density ratios to adjust mass flow rates from initialized ones // Hot water temperature is known, but condenser mass flow rates will be adjusted in the following "Do" loop - Real64 InitDensity = FluidProperties::GetDensityGlycol(state, + Real64 InitDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 EvapDensity = FluidProperties::GetDensityGlycol(state, + Real64 EvapDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CondDensity = FluidProperties::GetDensityGlycol(state, + Real64 CondDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2442,7 +2442,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Mode 4 uses all data from the chilled water loop due to no heating demand if (this->SimulClgDominant || CurrentMode == 3) { CurrentMode = 3; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -2557,7 +2557,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) PartLoadRat = 0.0; } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -2646,7 +2646,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Set load this chiller heater should meet and temperatures given QCondenser = min(HeatingLoadToMeet, QCondenser); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantChillers.cc b/src/EnergyPlus/PlantChillers.cc index a51e5cbca6c..82c29986718 100644 --- a/src/EnergyPlus/PlantChillers.cc +++ b/src/EnergyPlus/PlantChillers.cc @@ -855,7 +855,7 @@ namespace PlantChillers { if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -869,7 +869,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; // old behavior, still want? - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -896,7 +896,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1030,12 +1030,12 @@ namespace PlantChillers { Real64 tmpNomCap = this->NomCap; if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1152,12 +1152,12 @@ namespace PlantChillers { Real64 tmpCondVolFlowRate = this->CondVolFlowRate; if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1575,7 +1575,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1815,7 +1815,7 @@ namespace PlantChillers { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovered); - Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1906,7 +1906,7 @@ namespace PlantChillers { this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1914,7 +1914,7 @@ namespace PlantChillers { Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = FluidProperties::GetSpecificHeatGlycol(state, + CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2917,7 +2917,7 @@ namespace PlantChillers { // Initialize critical Demand Side Variables if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2932,7 +2932,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2958,7 +2958,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -3051,12 +3051,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3172,13 +3172,13 @@ namespace PlantChillers { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -3612,7 +3612,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3853,7 +3853,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -4008,7 +4008,7 @@ namespace PlantChillers { this->HeatRecMdotActual = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -4902,7 +4902,7 @@ namespace PlantChillers { if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -4916,7 +4916,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -4942,7 +4942,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -5035,12 +5035,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -5160,12 +5160,12 @@ namespace PlantChillers { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -5617,7 +5617,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -5843,7 +5843,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -5922,7 +5922,7 @@ namespace PlantChillers { // This mdot is input specified mdot "Desired Flowrate", already set at node in init routine heatRecMdot = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 HeatRecCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -6682,7 +6682,7 @@ namespace PlantChillers { // Initialize critical Demand Side Variables at the beginning of each environment if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -6695,7 +6695,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = TempDesCondIn; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -6787,12 +6787,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -6915,12 +6915,12 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -7247,7 +7247,7 @@ namespace PlantChillers { // condenser side outlet temperature. // local for fluid specif heat, for evaporator - Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -7437,7 +7437,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { // local for fluid specif heat, for condenser - Real64 const CpCond = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpCond = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantComponentTemperatureSources.cc b/src/EnergyPlus/PlantComponentTemperatureSources.cc index 03089902c9f..f9eaec46b5e 100644 --- a/src/EnergyPlus/PlantComponentTemperatureSources.cc +++ b/src/EnergyPlus/PlantComponentTemperatureSources.cc @@ -132,7 +132,7 @@ namespace PlantComponentTemperatureSources { // Initialize critical Demand Side Variables at the beginning of each environment if (this->MyEnvironFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -154,7 +154,7 @@ namespace PlantComponentTemperatureSources { } // Calculate specific heat - Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->BoundaryTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -364,7 +364,7 @@ namespace PlantComponentTemperatureSources { if (this->MassFlowRate > 0.0) { this->OutletTemp = this->BoundaryTemp; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->BoundaryTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantCondLoopOperation.cc b/src/EnergyPlus/PlantCondLoopOperation.cc index 39a5f69ed1b..2353b57dcdc 100644 --- a/src/EnergyPlus/PlantCondLoopOperation.cc +++ b/src/EnergyPlus/PlantCondLoopOperation.cc @@ -102,7 +102,7 @@ namespace EnergyPlus::PlantCondLoopOperation { // Using/Aliasing using namespace DataPlant; -using FluidProperties::GetSpecificHeatGlycol; +using Fluid::GetSpecificHeatGlycol; using HVAC::SmallLoad; void ManagePlantLoadDistribution(EnergyPlusData &state, @@ -3679,7 +3679,7 @@ void FindCompSPLoad(EnergyPlusData &state, // Using/Aliasing using DataLoopNode::SensedNodeFlagValue; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; // Locals // SUBROUTINE ARGUMENT DEFINITIONS: diff --git a/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc b/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc index 31d1dbb94b8..2bf0a4e077c 100644 --- a/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc +++ b/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc @@ -648,7 +648,7 @@ void HeatExchangerStruct::initialize(EnergyPlusData &state) if (state.dataGlobal->BeginEnvrnFlag && this->MyEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, @@ -660,7 +660,7 @@ void HeatExchangerStruct::initialize(EnergyPlusData &state) this->DemandSideLoop.inletNodeNum, this->DemandSideLoop.outletNodeNum); - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -807,13 +807,13 @@ void HeatExchangerStruct::size(EnergyPlusData &state) Real64 tmpDeltaTSupLoop = state.dataSize->PlantSizData(PltSizNumSupSide).DeltaT; if (tmpSupSideDesignVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -901,13 +901,13 @@ void HeatExchangerStruct::size(EnergyPlusData &state) } } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); Real64 SupSideMdot = this->SupplySideLoop.DesignVolumeFlowRate * rho; - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, @@ -996,7 +996,7 @@ void HeatExchangerStruct::control(EnergyPlusData &state, Real64 MyLoad, bool Fir state, mdotSupSide, this->SupplySideLoop.inletNodeNum, this->SupplySideLoop.outletNodeNum, this->SupplySideLoop); if (mdotSupSide > DataBranchAirLoopPlant::MassFlowTolerance) { // if supply side loop has massflow, request demand side flow - Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, this->SupplySideLoop.InletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -1031,7 +1031,7 @@ void HeatExchangerStruct::control(EnergyPlusData &state, Real64 MyLoad, bool Fir PlantUtilities::SetComponentFlowRate( state, mdotSupSide, this->SupplySideLoop.inletNodeNum, this->SupplySideLoop.outletNodeNum, this->SupplySideLoop); if (mdotSupSide > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, this->SupplySideLoop.InletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -1503,14 +1503,14 @@ void HeatExchangerStruct::calculate(EnergyPlusData &state, Real64 const SupSideM Real64 DmdSideLoopInletTemp = state.dataLoopNodes->Node(this->DemandSideLoop.inletNodeNum).Temp; // specific heat of fluid entering from supply side loop at inlet temp - Real64 SupSideLoopInletCp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 SupSideLoopInletCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, SupSideLoopInletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); // specific heat of fluid entering from demand side loop at inlet temp - Real64 DmdSideLoopInletCp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 DmdSideLoopInletCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, DmdSideLoopInletTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantLoadProfile.cc b/src/EnergyPlus/PlantLoadProfile.cc index fa976ca3efe..76b2a888990 100644 --- a/src/EnergyPlus/PlantLoadProfile.cc +++ b/src/EnergyPlus/PlantLoadProfile.cc @@ -142,7 +142,7 @@ void PlantProfileData::simulate(EnergyPlusData &state, if (this->FluidType == PlantLoopFluidType::Water) { if (this->MassFlowRate > 0.0) { - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -155,25 +155,25 @@ void PlantProfileData::simulate(EnergyPlusData &state, this->OutletTemp = this->InletTemp - DeltaTemp; } else if (this->FluidType == PlantLoopFluidType::Steam) { if (this->MassFlowRate > 0.0 && this->Power > 0.0) { - Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 1.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 0.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - Real64 SatTemp = FluidProperties::GetSatTemperatureRefrig(state, + Real64 SatTemp = Fluid::GetSatTemperatureRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataEnvironment::StdPressureSeaLevel, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, SatTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -232,18 +232,18 @@ void PlantProfileData::InitPlantProfile(EnergyPlusData &state) state.dataLoopNodes->Node(OutletNode).Temp = 0.0; if (this->FluidType == PlantLoopFluidType::Water) { - FluidDensityInit = FluidProperties::GetDensityGlycol(state, + FluidDensityInit = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); } else { //(this->FluidType == PlantLoopFluidType::Steam) - Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig(state, + Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataEnvironment::StdPressureSeaLevel, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - FluidDensityInit = FluidProperties::GetSatDensityRefrig(state, + FluidDensityInit = Fluid::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, SatTempAtmPress, 1.0, @@ -271,13 +271,13 @@ void PlantProfileData::InitPlantProfile(EnergyPlusData &state) if (this->EMSOverridePower) this->Power = this->EMSPowerValue; if (this->FluidType == PlantLoopFluidType::Water) { - FluidDensityInit = FluidProperties::GetDensityGlycol(state, + FluidDensityInit = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); } else { //(this->FluidType == PlantLoopFluidType::Steam) - FluidDensityInit = FluidProperties::GetSatDensityRefrig(state, + FluidDensityInit = Fluid::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 1.0, diff --git a/src/EnergyPlus/PlantLoopHeatPumpEIR.cc b/src/EnergyPlus/PlantLoopHeatPumpEIR.cc index 9eff1c9a64f..125b06fc88b 100644 --- a/src/EnergyPlus/PlantLoopHeatPumpEIR.cc +++ b/src/EnergyPlus/PlantLoopHeatPumpEIR.cc @@ -142,7 +142,7 @@ void EIRPlantLoopHeatPump::simulate( if (this->running) { if (this->sysControlType == ControlType::Setpoint) { Real64 leavingSetpoint = state.dataLoopNodes->Node(this->loadSideNodes.outlet).TempSetPoint; - Real64 CurSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CurSpecHeat = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInletTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -488,7 +488,7 @@ void EIRPlantLoopHeatPump::calcAvailableCapacity(EnergyPlusData &state, Real64 c if (this->heatRecoveryHeatPump) { // check to see if souce side outlet temp exceeds limit and reduce PLR if necessary auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol( + Real64 const CpSrc = Fluid::GetSpecificHeatGlycol( state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, "EIRPlantLoopHeatPump::doPhysics()"); Real64 const sourceMCp = this->sourceSideMassFlowRate * CpSrc; Real64 const tempSourceOutletTemp = @@ -556,7 +556,7 @@ void EIRPlantLoopHeatPump::calcLoadSideHeatTransfer(EnergyPlusData &state, Real6 { // evaluate the actual current operating load side heat transfer rate auto &thisLoadPlantLoop = state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum); - Real64 CpLoad = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpLoad = Fluid::GetSpecificHeatGlycol(state, thisLoadPlantLoop.FluidName, state.dataLoopNodes->Node(this->loadSideNodes.inlet).Temp, thisLoadPlantLoop.FluidIndex, @@ -610,7 +610,7 @@ void EIRPlantLoopHeatPump::calcSourceSideHeatTransferWSHP(EnergyPlusData &state) // calculate source side outlet conditions auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpSrc = Fluid::GetSpecificHeatGlycol(state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, @@ -658,7 +658,7 @@ void EIRPlantLoopHeatPump::calcHeatRecoveryHeatTransferASHP(EnergyPlusData &stat // calculate heat recovery side outlet conditions auto &thisHeatRecoveryPlantLoop = state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum); - Real64 const CpHR = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpHR = Fluid::GetSpecificHeatGlycol(state, thisHeatRecoveryPlantLoop.FluidName, this->heatRecoveryInletTemp, thisHeatRecoveryPlantLoop.FluidIndex, @@ -958,7 +958,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused if (state.dataGlobal->BeginEnvrnFlag && this->envrnInit && state.dataPlnt->PlantFirstSizesOkayToFinalize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -967,7 +967,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused PlantUtilities::InitComponentNodes(state, 0.0, this->loadSideDesignMassFlowRate, this->loadSideNodes.inlet, this->loadSideNodes.outlet); if (this->waterSource) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum).FluidIndex, @@ -980,7 +980,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused this->sourceSideDesignMassFlowRate = rho * this->sourceSideDesignVolFlowRate; // heat recovery if (this->heatRecoveryAvailable) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, @@ -1044,12 +1044,12 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRHeating) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; // I guess I can assume the plant fluids are the same for HW and CW. So only the sizing type is an issue on which to use. - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -1076,13 +1076,13 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) Real64 compCp = Cp; Real64 compDeltaT = deltaT; if (compLoopNum > 0) { - compRho = FluidProperties::GetDensityGlycol( + compRho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling ? Constant::HWInitConvTemp : Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - compCp = FluidProperties::GetSpecificHeatGlycol( + compCp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling ? Constant::HWInitConvTemp : Constant::CWInitConvTemp, @@ -1132,12 +1132,12 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; int compLoopNum = this->companionHeatPumpCoil->loadSidePlantLoc.loopNum; if (compLoopNum > 0) { - Real64 const compRho = FluidProperties::GetDensityGlycol(state, + Real64 const compRho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, compLoadSideInitTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - Real64 const compCp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const compCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, @@ -1311,12 +1311,12 @@ void EIRPlantLoopHeatPump::sizeSrcSideWSHP(EnergyPlusData &state) Real64 sourceSideInitTemp = (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::CWInitConvTemp : Constant::HWInitConvTemp; - Real64 const rhoSrc = FluidProperties::GetDensityGlycol(state, + Real64 const rhoSrc = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, sourceSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeSrcSideWSHP()"); - Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpSrc = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, sourceSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -1536,12 +1536,12 @@ void EIRPlantLoopHeatPump::sizeHeatRecoveryASHP(EnergyPlusData &state) std::string_view const typeName = DataPlant::PlantEquipTypeNames[static_cast(this->EIRHPType)]; Real64 heatRecoveryInitTemp = (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; - Real64 const rhoHR = FluidProperties::GetDensityGlycol(state, + Real64 const rhoHR = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, heatRecoveryInitTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeHeatRecoveryASHP()"); - Real64 const CpHR = FluidProperties::GetSpecificHeatGlycol(state, + Real64 const CpHR = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, heatRecoveryInitTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, @@ -2504,7 +2504,7 @@ void EIRFuelFiredHeatPump::doPhysics(EnergyPlusData &state, Real64 currentLoad) } DataPlant::PlantLoopData &thisLoadPlantLoop = state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum); - Real64 CpLoad = FluidProperties::GetSpecificHeatGlycol( + Real64 CpLoad = Fluid::GetSpecificHeatGlycol( state, thisLoadPlantLoop.FluidName, thisInletNode.Temp, thisLoadPlantLoop.FluidIndex, "PLFFHPEIR::simulate()"); // Set the current load equal to the FFHP load @@ -2890,7 +2890,7 @@ void EIRFuelFiredHeatPump::doPhysics(EnergyPlusData &state, Real64 currentLoad) Real64 CpSrc = 0.0; if (this->waterSource) { auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - CpSrc = FluidProperties::GetSpecificHeatGlycol( + CpSrc = Fluid::GetSpecificHeatGlycol( state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, "PLFFHPEIR::simulate()"); } else if (this->airSource) { CpSrc = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat); diff --git a/src/EnergyPlus/PlantPipingSystemsManager.cc b/src/EnergyPlus/PlantPipingSystemsManager.cc index dc8deb1da92..a4537988cf5 100644 --- a/src/EnergyPlus/PlantPipingSystemsManager.cc +++ b/src/EnergyPlus/PlantPipingSystemsManager.cc @@ -2109,7 +2109,7 @@ namespace PlantPipingSystemsManager { } // Once we find ourselves on the plant loop, we can do other things - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, @@ -5689,22 +5689,22 @@ namespace PlantPipingSystemsManager { // retrieve fluid properties based on the circuit inlet temperature -- which varies during the simulation // but need to verify the value of inlet temperature during warm up, etc. - FluidCp = FluidProperties::GetSpecificHeatGlycol(state, + FluidCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidDensity = FluidProperties::GetDensityGlycol(state, + FluidDensity = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidConductivity = FluidProperties::GetConductivityGlycol(state, + FluidConductivity = Fluid::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidViscosity = FluidProperties::GetViscosityGlycol(state, + FluidViscosity = Fluid::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantPressureSystem.cc b/src/EnergyPlus/PlantPressureSystem.cc index dc15cff6b4c..8f04efbdc57 100644 --- a/src/EnergyPlus/PlantPressureSystem.cc +++ b/src/EnergyPlus/PlantPressureSystem.cc @@ -375,8 +375,8 @@ void BranchPressureDrop(EnergyPlusData &state, // Using/Aliasing using Curve::CurveValue; using Curve::PressureCurveValue; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetViscosityGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetViscosityGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("CalcPlantPressureSystem"); @@ -839,8 +839,8 @@ Real64 ResolveLoopFlowVsPressure(EnergyPlusData &state, // Using/Aliasing using Curve::CurveValue; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetViscosityGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetViscosityGlycol; // Return value Real64 ResolvedLoopMassFlowRate; diff --git a/src/EnergyPlus/PlantUtilities.cc b/src/EnergyPlus/PlantUtilities.cc index 3d442924399..493e3f2fed3 100644 --- a/src/EnergyPlus/PlantUtilities.cc +++ b/src/EnergyPlus/PlantUtilities.cc @@ -985,7 +985,7 @@ void UpdateChillerComponentCondenserSide(EnergyPlusData &state, // update outlet conditions if needed or possible // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("UpdateChillerComponentCondenserSide"); @@ -1079,7 +1079,7 @@ void UpdateComponentHeatRecoverySide(EnergyPlusData &state, // update outlet conditions if needed or possible // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("UpdateComponentHeatRecoverySide"); diff --git a/src/EnergyPlus/PondGroundHeatExchanger.cc b/src/EnergyPlus/PondGroundHeatExchanger.cc index 1a5542223d5..f7837cfa626 100644 --- a/src/EnergyPlus/PondGroundHeatExchanger.cc +++ b/src/EnergyPlus/PondGroundHeatExchanger.cc @@ -207,7 +207,7 @@ void GetPondGroundHeatExchanger(EnergyPlusData &state) state.dataIPShortCut->cAlphaFieldNames, state.dataIPShortCut->cNumericFieldNames); - state.dataPondGHE->PondGHE(Item).WaterIndex = FluidProperties::FindGlycol(state, fluidNameWater); + state.dataPondGHE->PondGHE(Item).WaterIndex = Fluid::FindGlycol(state, fluidNameWater); // General user input data state.dataPondGHE->PondGHE(Item).Name = state.dataIPShortCut->cAlphaArgs(1); @@ -470,10 +470,10 @@ void PondGroundHeatExchangerData::CalcPondGroundHeatExchanger(EnergyPlusData &st static constexpr std::string_view RoutineName("CalcPondGroundHeatExchanger"); Real64 PondMass = this->Depth * this->Area * - FluidProperties::GetDensityGlycol( + Fluid::GetDensityGlycol( state, fluidNameWater, max(this->PondTemp, DataPrecisionGlobals::constant_zero), this->WaterIndex, RoutineName); - Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol( + Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol( state, fluidNameWater, max(this->PondTemp, DataPrecisionGlobals::constant_zero), this->WaterIndex, RoutineName); Real64 Flux = this->CalcTotalFLux(state, this->PondTemp); @@ -571,7 +571,7 @@ Real64 PondGroundHeatExchangerData::CalcTotalFLux(EnergyPlusData &state, Real64 Real64 FluxSolAbsorbed = CalcSolarFlux(state); // specific heat from fluid prop routines - Real64 SpecHeat = FluidProperties::GetSpecificHeatGlycol(state, + Real64 SpecHeat = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, max(this->InletTemp, 0.0), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -713,17 +713,17 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, // evaluate properties at pipe fluid temperature for given pipe fluid - Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol(state, + Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Conductivity = FluidProperties::GetConductivityGlycol(state, + Real64 Conductivity = Fluid::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Viscosity = FluidProperties::GetViscosityGlycol(state, + Real64 Viscosity = Fluid::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -747,10 +747,10 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, Real64 ConvCoefIn = Conductivity * NusseltNum / this->TubeInDiameter; // now find properties of pond water - always assume pond fluid is water - Real64 WaterSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterConductivity = FluidProperties::GetConductivityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterViscosity = FluidProperties::GetViscosityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterDensity = FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterSpecHeat = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterConductivity = Fluid::GetConductivityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterViscosity = Fluid::GetViscosityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterDensity = Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); // derived properties for natural convection coefficient // expansion coef (Beta) = -1/Rho. dRho/dT @@ -758,8 +758,8 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, // It guarantees that the delta T is 10C and also avoids the problems associated with // water hitting a maximum density at around 4C. (RKS) Real64 ExpansionCoef = - -(FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) + 5.0, this->WaterIndex, CalledFrom) - - FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) - 5.0, this->WaterIndex, CalledFrom)) / + -(Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) + 5.0, this->WaterIndex, CalledFrom) - + Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) - 5.0, this->WaterIndex, CalledFrom)) / (10.0 * WaterDensity); Real64 ThermDiff = WaterConductivity / (WaterDensity * WaterSpecHeat); @@ -842,7 +842,7 @@ void PondGroundHeatExchangerData::UpdatePondGroundHeatExchanger(EnergyPlusData & // Calculate the water side outlet conditions and set the // appropriate conditions on the correct HVAC node. - Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -898,12 +898,12 @@ void PondGroundHeatExchangerData::oneTimeInit(EnergyPlusData &state) if (errFlag) { ShowFatalError(state, "InitPondGroundHeatExchanger: Program terminated due to previous condition(s)."); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataPrecisionGlobals::constant_zero, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataPrecisionGlobals::constant_zero, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 61b5a745745..76b8a1a0075 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -115,7 +115,6 @@ using namespace ScheduleManager; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using SteamCoils::SimulateSteamCoilComponents; -using namespace FluidProperties; constexpr const char *fluidNameSteam("STEAM"); constexpr const char *fluidNameWater("WATER"); @@ -232,7 +231,7 @@ void GetPIUs(EnergyPlusData &state) using BranchNodeConnections::SetUpCompSets; using BranchNodeConnections::TestCompSet; - using FluidProperties::FindRefrigerant; + using Fluid::FindRefrigerant; using NodeInputManager::GetOnlySingleNode; using SteamCoils::GetCoilSteamInletNode; using WaterCoils::GetCoilWaterInletNode; @@ -724,7 +723,7 @@ void InitPIU(EnergyPlusData &state, if (thisPIU.HotControlNode > 0) { // plant upgrade note? why no separate handling of steam coil? add it ? // local plant fluid density - Real64 const rho = GetDensityGlycol(state, + Real64 const rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidIndex, @@ -854,8 +853,8 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using SteamCoils::GetCoilSteamInletNode; using SteamCoils::GetCoilSteamOutletNode; using WaterCoils::GetCoilWaterInletNode; @@ -1309,12 +1308,12 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) DesCoilLoad = PsyCpAirFnW(CoilOutHumRat) * DesMassFlow * (CoilOutTemp - CoilInTemp); Real64 constexpr TempSteamIn = 100.00; Real64 const EnthSteamInDry = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; Real64 const SteamDensity = - GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); int DummyWaterIndex = 1; Real64 const Cp = GetSpecificHeatGlycol( state, fluidNameWater, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, DummyWaterIndex, RoutineName); @@ -1421,8 +1420,8 @@ void CalcSeriesPIU(EnergyPlusData &state, // Using/Aliasing using namespace DataZoneEnergyDemands; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using HeatingCoils::SimulateHeatingCoilComponents; using MixerComponent::SimAirMixer; using PlantUtilities::SetComponentFlowRate; diff --git a/src/EnergyPlus/Pumps.cc b/src/EnergyPlus/Pumps.cc index b22f78716f8..9799fa8d4ef 100644 --- a/src/EnergyPlus/Pumps.cc +++ b/src/EnergyPlus/Pumps.cc @@ -217,8 +217,8 @@ void GetPumpInput(EnergyPlusData &state) using Curve::GetCurveIndex; using Curve::GetCurveMinMaxValues; using DataSizing::AutoSize; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSatDensityRefrig; + using Fluid::GetDensityGlycol; + using Fluid::GetSatDensityRefrig; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::CheckScheduleValueMinMax; using ScheduleManager::GetScheduleIndex; @@ -1353,8 +1353,8 @@ void InitializePumps(EnergyPlusData &state, int const PumpNum) // This subroutine does one-time and begin-envrn inits for the pump // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSatDensityRefrig; + using Fluid::GetDensityGlycol; + using Fluid::GetSatDensityRefrig; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1579,7 +1579,7 @@ void SetupPumpMinMaxFlows(EnergyPlusData &state, int const LoopNum, int const Pu // These values are also bounded by EMS overridable limit of max flow rate. // Using/Aliasing - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantPressureSystem::ResolveLoopFlowVsPressure; using PlantUtilities::BoundValueToWithinTwoValues; using ScheduleManager::GetCurrentScheduleValue; @@ -1756,8 +1756,8 @@ void CalcPumps(EnergyPlusData &state, int const PumpNum, Real64 const FlowReques // Energy Calculations, ASHRAE, 1993, pp2-10 to 2-15 // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; using ScheduleManager::GetCurrentScheduleValue; @@ -2018,8 +2018,8 @@ void SizePump(EnergyPlusData &state, int const PumpNum) // Obtains flow rates from the plant sizing array. // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSatDensityRefrig; + using Fluid::GetDensityGlycol; + using Fluid::GetSatDensityRefrig; // SUBROUTINE PARAMETER DEFINITIONS: Real64 constexpr StartTemp(100.0); // Standard Temperature across code to calculated Steam density @@ -2325,8 +2325,8 @@ void GetRequiredMassFlowRate(EnergyPlusData &state, Real64 &PumpMaxMassFlowRateVFDRange) { // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantPressureSystem::ResolveLoopFlowVsPressure; using PlantUtilities::SetComponentFlowRate; diff --git a/src/EnergyPlus/RefrigeratedCase.cc b/src/EnergyPlus/RefrigeratedCase.cc index ec4e4873db0..d2e406cb097 100644 --- a/src/EnergyPlus/RefrigeratedCase.cc +++ b/src/EnergyPlus/RefrigeratedCase.cc @@ -4658,10 +4658,10 @@ void GetRefrigerationInput(EnergyPlusData &state) TBrineInRated = TBrineOutRated + Secondary(SecondaryNum).TRangeDifRated; Real64 TBrineAverage = (TBrineOutRated + TBrineInRated) / 2.0; Secondary(SecondaryNum).TBrineAverage = TBrineAverage; - DensityBrineRated = FluidProperties::GetDensityGlycol( + DensityBrineRated = Fluid::GetDensityGlycol( state, Secondary(SecondaryNum).FluidName, TBrineAverage, Secondary(SecondaryNum).FluidID, TrackMessage); Secondary(SecondaryNum).DensityBrineRated = DensityBrineRated; - CpBrineRated = FluidProperties::GetSpecificHeatGlycol( + CpBrineRated = Fluid::GetSpecificHeatGlycol( state, Secondary(SecondaryNum).FluidName, TBrineAverage, Secondary(SecondaryNum).FluidID, TrackMessage); Secondary(SecondaryNum).CpBrineRated = CpBrineRated; @@ -4742,19 +4742,19 @@ void GetRefrigerationInput(EnergyPlusData &state) Secondary(SecondaryNum).CircRate = DefaultCircRate; if (!lNumericBlanks(10)) Secondary(SecondaryNum).CircRate = Numbers(10); - DensityPhaseChange = FluidProperties::GetSatDensityRefrig(state, + DensityPhaseChange = Fluid::GetSatDensityRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 0.0, Secondary(SecondaryNum).FluidID, TrackMessageAlt); - DeltaHPhaseChange = FluidProperties::GetSatEnthalpyRefrig(state, + DeltaHPhaseChange = Fluid::GetSatEnthalpyRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 1.0, Secondary(SecondaryNum).FluidID, TrackMessageAlt) - - FluidProperties::GetSatEnthalpyRefrig(state, + Fluid::GetSatEnthalpyRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 0.0, @@ -6230,15 +6230,15 @@ void GetRefrigerationInput(EnergyPlusData &state) // Determine intercooler pressure and temperature at design conditions if (System(RefrigSysNum).NumStages == 2) { - Real64 PCond = FluidProperties::GetSatPressureRefrig(state, + Real64 PCond = Fluid::GetSatPressureRefrig(state, System(RefrigSysNum).RefrigerantName, Condenser(System(RefrigSysNum).CondenserNum(1)).RatedTCondense, System(RefrigSysNum).RefIndex, RoutineName); - Real64 PEvap = FluidProperties::GetSatPressureRefrig( + Real64 PEvap = Fluid::GetSatPressureRefrig( state, System(RefrigSysNum).RefrigerantName, System(RefrigSysNum).TEvapDesign, System(RefrigSysNum).RefIndex, RoutineName); System(RefrigSysNum).PIntercooler = std::sqrt(PCond * PEvap); - System(RefrigSysNum).TIntercooler = FluidProperties::GetSatTemperatureRefrig( + System(RefrigSysNum).TIntercooler = Fluid::GetSatTemperatureRefrig( state, System(RefrigSysNum).RefrigerantName, System(RefrigSysNum).PIntercooler, System(RefrigSysNum).RefIndex, RoutineName); } // NumStages @@ -6846,7 +6846,7 @@ void GetRefrigerationInput(EnergyPlusData &state) if (Compressor(CompNum).TransFlag) { // Calculate nominal capacity of transcritical Compressor Real64 GCOutletH = - FluidProperties::GetSupHeatEnthalpyRefrig(state, + Fluid::GetSupHeatEnthalpyRefrig(state, TransSystem(TransRefrigSysNum).RefrigerantName, GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(1)).RatedOutletT, GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(1)).RatedOutletP, @@ -6948,7 +6948,7 @@ void GetRefrigerationInput(EnergyPlusData &state) } // Check receiver temperature against minimum condensing temperature (from gas cooler input) and design evaporator temperatures - TransSystem(TransRefrigSysNum).TReceiver = FluidProperties::GetSatTemperatureRefrig( + TransSystem(TransRefrigSysNum).TReceiver = Fluid::GetSatTemperatureRefrig( state, TransSystem(TransRefrigSysNum).RefrigerantName, TransSystem(TransRefrigSysNum).PReceiver, RefrigIndex, RoutineNameNoColon); if (TransSystem(TransRefrigSysNum).TReceiver > GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(NumGasCoolers)).MinCondTemp) { ShowWarningError(state, @@ -10651,7 +10651,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidIndex, @@ -10682,7 +10682,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidIndex, @@ -10707,7 +10707,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) for (int RefCondLoop = 1; RefCondLoop <= state.dataRefrigCase->NumRefrigCondensers; ++RefCondLoop) { if (Condenser(RefCondLoop).CondenserType != DataHeatBalance::RefrigCondenserType::Water) continue; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidIndex, @@ -10725,7 +10725,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) for (int RefCompRackLoop = 1; RefCompRackLoop <= state.dataRefrigCase->NumRefrigeratedRacks; ++RefCompRackLoop) { if (RefrigRack(RefCompRackLoop).CondenserType != DataHeatBalance::RefrigCondenserType::Water) continue; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidIndex, @@ -11612,12 +11612,12 @@ void RefrigCondenserData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, @@ -11772,12 +11772,12 @@ void RefrigRackData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, @@ -12159,9 +12159,9 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) // only calc detailed system if have load (could be zero first time through if only load is cascade condenser) thisSys.TotalSystemLoad = thisSys.TotalCoolingLoad + thisSys.SumSecondaryLoopLoad + thisSys.SumMechSCLoad + thisSys.SumCascadeLoad; if (thisSys.TotalSystemLoad > 0.0) { - thisSys.CpSatVapEvap = FluidProperties::GetSatSpecificHeatRefrig( + thisSys.CpSatVapEvap = Fluid::GetSatSpecificHeatRefrig( state, thisSys.RefrigerantName, thisSys.TEvapNeeded, 1.0, thisSys.RefIndex, RoutineName); - thisSys.HCaseOut = FluidProperties::GetSatEnthalpyRefrig( + thisSys.HCaseOut = Fluid::GetSatEnthalpyRefrig( state, thisSys.RefrigerantName, thisSys.TEvapNeeded, 1.0, thisSys.RefIndex, RoutineName) + thisSys.CpSatVapEvap * CaseSuperheat; // Establish estimates to start solution loop @@ -12187,8 +12187,8 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) // Produce first time step estimates, assume no subcoolers thisSys.HSatLiqCond = - FluidProperties::GetSatEnthalpyRefrig(state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); - thisSys.CpSatLiqCond = FluidProperties::GetSatSpecificHeatRefrig( + Fluid::GetSatEnthalpyRefrig(state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); + thisSys.CpSatLiqCond = Fluid::GetSatSpecificHeatRefrig( state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); thisSys.HCaseIn = thisSys.HSatLiqCond - thisSys.CpSatLiqCond * Condenser(thisSys.CondenserNum(1)).RatedSubcool; thisSys.RefMassFlowtoLoads = thisSys.TotalSystemLoad / (thisSys.HCaseOut - thisSys.HCaseIn); @@ -12475,24 +12475,24 @@ void SimulateDetailedTransRefrigSystems(EnergyPlusData &state) if (sys.TotalSystemLoad > 0.0) { if (sys.TransSysType == 2) { sys.CpSatVapEvapLT = - FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName); sys.HCaseOutLT = - FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName) + + Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName) + sys.CpSatVapEvapLT * TransCaseSuperheat; } sys.CpSatVapEvapMT = - FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName); sys.HCaseOutMT = - FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName) + + Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName) + sys.CpSatVapEvapMT * TransCaseSuperheat; // Produce first time step estimates. // Assume no subcoolers and neglect flow through bypass. - sys.TReceiver = FluidProperties::GetSatTemperatureRefrig(state, sys.RefrigerantName, sys.PReceiver, sys.RefIndex, RoutineName); + sys.TReceiver = Fluid::GetSatTemperatureRefrig(state, sys.RefrigerantName, sys.PReceiver, sys.RefIndex, RoutineName); sys.HSatLiqReceiver = - FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); sys.CpSatLiqReceiver = - FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); sys.HCaseInMT = sys.HSatLiqReceiver; sys.HCaseInLT = sys.HSatLiqReceiver; sys.RefMassFlowtoLTLoads = 0.0; @@ -13211,7 +13211,7 @@ void TransRefrigSystemData::CalcGasCooler(EnergyPlusData &state, int const SysNu if (cooler.PGasCoolerOut < 7.5e6) { // Ensure gas cooler pressure is at least 7.5 MPa for transcritical operation cooler.PGasCoolerOut = 7.5e6; } - cooler.HGasCoolerOut = FluidProperties::GetSupHeatEnthalpyRefrig( + cooler.HGasCoolerOut = Fluid::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, cooler.TGasCoolerOut, cooler.PGasCoolerOut, this->RefIndex, RoutineName); cooler.TransOpFlag = true; } else { // Gas cooler in subcritical operation @@ -13219,23 +13219,23 @@ void TransRefrigSystemData::CalcGasCooler(EnergyPlusData &state, int const SysNu if (cooler.TGasCoolerOut > 30.978) { // Gas temperature should be less than critical temperature cooler.PGasCoolerOut = 7.2e6; // Fix the pressure to be subcritical cooler.TGasCoolerOut = - FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, cooler.PGasCoolerOut, this->RefIndex, RoutineName); + Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, cooler.PGasCoolerOut, this->RefIndex, RoutineName); } else if (cooler.TGasCoolerOut > cooler.MinCondTemp) { // Allow condensing temperature to float above the minimum cooler.PGasCoolerOut = - FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); + Fluid::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); } else { // Don't allow condensing temperature to drop below minimum cooler.TGasCoolerOut = cooler.MinCondTemp; cooler.PGasCoolerOut = - FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); + Fluid::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); } cooler.HGasCoolerOut = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); cooler.TransOpFlag = false; } // (OutDbTemp > TransitionTemperature) if (cooler.TGasCoolerOut < 30.978) { cooler.CpGasCoolerOut = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); } else { cooler.CpGasCoolerOut = 0.0; } @@ -13385,11 +13385,11 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) TsatforPdisch = this->TCondense + DelTDischPipes; // need (Psat of (Tcond + delT corresponding to delP disch Pipes)) TsatforPsuct = this->TEvapNeeded - DelTSuctPipes; // need (Psat of (Tevap - delT corresponding to del P suct Pipes)) HsatVaporforTevapneeded = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); this->HSatLiqCond = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); // HCaseIn is a function of the condenser rated subcooling, not the compressor rated subcooling // TCompIn needs to include case superheat as well as Temp change from lshx subcoolers // Calculate both here unless set previously by subcooler subroutine @@ -13403,23 +13403,23 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } else { // subcooler subroutine has been called to calc TCompIn and HCaseIn this->HCompIn = this->HCaseOut + this->CpSatVapEvap * (this->TCompIn - (this->TEvapNeeded + CaseSuperheat)); } // whether or not subcooler routine used - PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumCompressors; } else { // Low-stage side of two-stage system - PCond = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, this->TCondense, this->RefIndex, RoutineName); - PEvap = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, this->TEvapNeeded, this->RefIndex, RoutineName); + PCond = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, this->TCondense, this->RefIndex, RoutineName); + PEvap = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, this->TEvapNeeded, this->RefIndex, RoutineName); this->PIntercooler = std::sqrt(PCond * PEvap); this->TIntercooler = - FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, this->PIntercooler, this->RefIndex, RoutineName); + Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, this->PIntercooler, this->RefIndex, RoutineName); NeededCapacity = NeededCapacity_base; // because compressor capacity rated from txv to comp inlet TsatforPdisch = this->TIntercooler + DelTDischPipes; // need (Psat of (Tinter + delT corresponding to delP disch Pipes)) TsatforPsuct = this->TEvapNeeded - DelTSuctPipes; // need (Psat of (Tevap - delT corresponding to del P suct Pipes)) HsatVaporforTevapneeded = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); this->HSatLiqCond = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); // HCaseIn is a function of the condenser rated subcooling, not the compressor rated subcooling // TCompIn needs to include case superheat as well as Temp change from lshx subcoolers // Calculate both here unless set previously by subcooler subroutine @@ -13427,7 +13427,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) if (this->NumSubcoolers == 0) { // No subcooler on this system if (this->IntercoolerType == 1) { // Flash Intercooler this->HCaseIn = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); this->TLiqInActual = this->TIntercooler; } else if (this->IntercoolerType == 2) { // Shell-and-Coil Intercooler this->TLiqInActual = this->TCondense - Condenser1.RatedSubcool - @@ -13439,7 +13439,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } else { // subcooler subroutine has been called to calc TCompIn and HCaseIn this->HCompIn = this->HCaseOut + this->CpSatVapEvap * (this->TCompIn - (this->TEvapNeeded + CaseSuperheat)); } // whether or not subcooler routine used - PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumCompressors; } // NumStages } else { // Two-stage system, high-stage side @@ -13447,24 +13447,24 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) TsatforPdisch = this->TCondense + DelTDischPipes; TsatforPsuct = this->TIntercooler; HsatVaporforTevapneeded = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); - // HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, RefrigerantName, TCondense, 0.0, RefIndex, + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + // HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, RefrigerantName, TCondense, 0.0, RefIndex, // RoutineName //); ////Autodesk:Tuned These don't change for 2nd stage - // CpSatLiqCond = FluidProperties::GetSatSpecificHeatRefrig(RefrigerantName, TCondense, 0.0, RefIndex, + // CpSatLiqCond = Fluid::GetSatSpecificHeatRefrig(RefrigerantName, TCondense, 0.0, RefIndex, // RoutineName ); ////Autodesk:Tuned These don't change for 2nd stage this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * Condenser1.RatedSubcool; this->TCompIn = this->TIntercooler; // System(SysNum)%TLiqInActual = System(SysNum)%TCondense-Condenser(System(SysNum)%CondenserNum(1))%RatedSubcool this->HCompIn = HsatVaporforTevapneeded; - PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumHiStageCompressors; } // StageIndex // dispatch compressors to meet load, note they were listed in compressor list in dispatch order - DensityActual = FluidProperties::GetSupHeatDensityRefrig(state, + DensityActual = Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompIn, PSuction, @@ -13474,10 +13474,10 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) if (this->NumStages == 2) { // Autodesk:Tuned Hoisted out of CompIndex loop if (StageIndex == 1) { HCaseInRated_base = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); } else if (StageIndex == 2) { HCompInRated_base = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); } } for (int CompIndex = 1; CompIndex <= NumComps; ++CompIndex) { @@ -13542,7 +13542,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } // Compressor SuperheatRatingType CaseEnthalpyChangeRated = HCompInRated - HCaseInRated; - DensityRated = FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRated, PSuction, this->RefIndex, RoutineName); + DensityRated = Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRated, PSuction, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling MassCorrection = DensityActual / DensityRated; @@ -13602,13 +13602,13 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) this->HCompOut = this->HCompIn + this->TotCompPower / this->RefMassFlowComps; // error found 9/19/2011, was System(SysNum)%TotCompPower*LocalTimeStep*DataGlobals::SecInHour/System(SysNum)%RefMassFlowComps } else { // High-stage compressors (only for two-stage systems) - HHiStageCompIn = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + HHiStageCompIn = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); this->HCompOut = HHiStageCompIn + this->TotHiStageCompPower / this->RefMassFlowHiStageComps; } // Calculate superheat energy available for desuperheaters - HSatVapCondense = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); - CpSatVapCondense = FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); + HSatVapCondense = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); + CpSatVapCondense = Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); if (this->NumStages == 1) { // Single-stage systems state.dataHeatBal->HeatReclaimRefrigCondenser(CondID).AvailCapacity = this->RefMassFlowComps * (this->HCompOut - HSatVapCondense); } else { // Two-stage systems @@ -13736,10 +13736,10 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) // Determine refrigerant properties at receiver this->CpSatLiqReceiver = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TReceiver, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TReceiver, 0.0, this->RefIndex, RoutineName); // Enthalpy at the receiver bypass, J/kg - Real64 HReceiverBypass = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, 1.0, this->RefIndex, RoutineName); + Real64 HReceiverBypass = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, 1.0, this->RefIndex, RoutineName); // Determine refrigerant properties at low temperature (LT) loads (if present) // Dispatch low pressure (LP) compressors as necessary @@ -13751,12 +13751,12 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) TsatforPsucLT = this->TEvapNeededLT; TsatforPdisLT = this->TEvapNeededMT; HsatVaporforTevapneededLT = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededLT, 1.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededLT, 1.0, this->RefIndex, RoutineName); HsatLiqforTevapNeededMT = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 0.0, this->RefIndex, RoutineName); - PSuctionLT = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucLT, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 0.0, this->RefIndex, RoutineName); + PSuctionLT = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucLT, this->RefIndex, RoutineName); DensityActualLT = - FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInLP, PSuctionLT, this->RefIndex, RoutineName); + Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInLP, PSuctionLT, this->RefIndex, RoutineName); TotalEnthalpyChangeActualLT = this->HCompInLP - this->HCaseInLT; // Dispatch low pressure (LP) compressors @@ -13785,7 +13785,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } break; case CompRatingType::LiquidTemperature: { // have rated liquid temperature stored in "RatedSubcool" HCaseInRatedLT = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); } break; default: break; @@ -13798,7 +13798,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) case CompRatingType::ReturnGasTemperature: { // have rated compressor inlet temperature stored in // "CompRatingType::Superheat" TempInRatedLP = compressor.RatedSuperheat; - HCompInRatedLP = FluidProperties::GetSupHeatEnthalpyRefrig( + HCompInRatedLP = Fluid::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, compressor.RatedSuperheat, PSuctionLT, this->RefIndex, RoutineName); } break; default: @@ -13807,7 +13807,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) CaseEnthalpyChangeRatedLT = HCompInRatedLP - HCaseInRatedLT; DensityRatedLP = - FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedLP, PSuctionLT, this->RefIndex, RoutineName); + Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedLP, PSuctionLT, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling @@ -13849,10 +13849,10 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } else { // Transcritical system is operating in subcritical region TsatforPdisMT = GasCooler(this->GasCoolerNum(1)).TGasCoolerOut; } - PSuctionMT = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucMT, this->RefIndex, RoutineName); + PSuctionMT = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucMT, this->RefIndex, RoutineName); PGCOutlet = GasCooler(this->GasCoolerNum(1)).PGasCoolerOut; HsatVaporforTevapneededMT = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 1.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 1.0, this->RefIndex, RoutineName); this->HCaseInMT = this->HSatLiqReceiver; // Enthalpy of refrigerant after leaving medium temperature loads and low pressure compressors @@ -13869,7 +13869,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations to find receiver quality QualityReceiver = (Xu + Xl) / 2.0; Real64 Hnew = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, QualityReceiver, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, QualityReceiver, this->RefIndex, RoutineName); // estimated QualityReceiver is too high if (Hnew > (GasCooler(this->GasCoolerNum(1)).HGasCoolerOut + this->DelHSubcoolerDis)) { @@ -13890,11 +13890,11 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) (this->RefMassFlowtoLTLoads + this->RefMassFlowtoMTLoads + this->RefMassFlowReceiverBypass); // Iterate to find the suction temperature entering subcooler - Xl = FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); + Xl = Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); Xu = Xl + 50.0; for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations Xnew = (Xu + Xl) / 2.0; - Real64 Hnew = FluidProperties::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); + Real64 Hnew = Fluid::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); if (Hnew > this->HCompInHP) { // xnew is too high Xu = Xnew; } else { // xnew is too low @@ -13905,7 +13905,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) TSubcoolerColdIn = Xnew; // Modify receiver inlet enthalpy and HP compressor inlet enthalpy to account for subcooler - HIdeal = FluidProperties::GetSupHeatEnthalpyRefrig( + HIdeal = Fluid::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, GasCooler(this->GasCoolerNum(1)).TGasCoolerOut, PSuctionMT, this->RefIndex, RoutineName); // Only use subcooler if suction gas inlet temperature less than gas cooler outlet temperature if (TSubcoolerColdIn < GasCooler(this->GasCoolerNum(1)).TGasCoolerOut) { @@ -13918,11 +13918,11 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) this->DelHSubcoolerDis = -this->DelHSubcoolerSuc; // Iterate to find the temperature at the inlet of the high pressure (HP) compressors - Xl = FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); + Xl = Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); Xu = Xl + 50.0; for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations Xnew = (Xu + Xl) / 2.0; - Real64 Hnew = FluidProperties::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); + Real64 Hnew = Fluid::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); if (Hnew > this->HCompInHP) { // xnew is too high Xu = Xnew; } else { // xnew is too low @@ -13936,7 +13936,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) // to constitute the "load". The actual and rated conditions at the exit of the gas cooler and the inlet of the // HP compressors are used for capacity correction calculations. DensityActualMT = - FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInHP, PSuctionMT, this->RefIndex, RoutineName); + Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInHP, PSuctionMT, this->RefIndex, RoutineName); TotalEnthalpyChangeActualMT = this->HCompInHP - GasCooler(this->GasCoolerNum(1)).HGasCoolerOut; // Dispatch HP compressors @@ -13975,7 +13975,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) case CompRatingType::LiquidTemperature: { // have rated liquid temperature stored in "RatedSubcool" if (!GasCooler(this->GasCoolerNum(1)).TransOpFlag) { // Subcritical operation HCaseInRatedMT = - FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); } else { // Transcritical operation HCaseInRatedMT = GasCooler(this->GasCoolerNum(1)).HGasCoolerOut; } // (.NOT.GasCooler(SysNum)%TransOpFlag) @@ -13990,7 +13990,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } break; case CompRatingType::ReturnGasTemperature: { // have rated compressor inlet temperature stored in "RatedSuperheat" TempInRatedHP = compressor.RatedSuperheat; - HCompInRatedHP = FluidProperties::GetSupHeatEnthalpyRefrig( + HCompInRatedHP = Fluid::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, compressor.RatedSuperheat, PSuctionMT, this->RefIndex, RoutineName); } break; default: @@ -13999,7 +13999,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) CaseEnthalpyChangeRatedMT = HCompInRatedHP - HCaseInRatedMT; DensityRatedHP = - FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedHP, PSuctionMT, this->RefIndex, RoutineName); + Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedHP, PSuctionMT, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling MassCorrectionMT = DensityActualMT / DensityRatedHP; @@ -14080,25 +14080,25 @@ void RefrigSystemData::CalculateSubcoolers(EnergyPlusData &state) // HCaseIn has to be recalculated as the starting point for the subcoolers here because // of the multiple number of iterations through this subroutine and because Tcondense is evolving. if (this->NumStages == 1) { // Single-stage compression system - this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * Condenser(this->CondenserNum(1)).RatedSubcool; // Two-stage compression with flash intercooler } else if (this->NumStages == 2 && this->IntercoolerType == 1) { - this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); - this->HCaseIn = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HCaseIn = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); // Two-stage compression with shell-and-coil intercooler } else if (this->NumStages == 2 && this->IntercoolerType == 2) { TLiqInActualLocal = this->TCondense - Condenser(this->CondenserNum(1)).RatedSubcool - this->IntercoolerEffectiveness * (this->TCondense - Condenser(this->CondenserNum(1)).RatedSubcool - this->TIntercooler); - this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * (this->TCondense - TLiqInActualLocal); } // NumStages and IntercoolerType diff --git a/src/EnergyPlus/ReportCoilSelection.cc b/src/EnergyPlus/ReportCoilSelection.cc index e46290b92e2..e1a237c4225 100644 --- a/src/EnergyPlus/ReportCoilSelection.cc +++ b/src/EnergyPlus/ReportCoilSelection.cc @@ -807,25 +807,25 @@ void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state) c->plantLoopName = state.dataPlnt->PlantLoop(c->waterLoopNum).Name; if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) { - c->rhoFluid = FluidProperties::GetDensityGlycol(state, + c->rhoFluid = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); - c->cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + c->cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); } else { // steam loop - c->rhoFluid = FluidProperties::GetSatDensityRefrig(state, + c->rhoFluid = Fluid::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 1.0, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); - c->cpFluid = FluidProperties::GetSatSpecificHeatRefrig(state, + c->cpFluid = Fluid::GetSatSpecificHeatRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 0.0, @@ -1080,25 +1080,25 @@ void ReportCoilSelection::setCoilWaterFlowPltSizNum(EnergyPlusData &state, if (c->waterLoopNum > 0 && c->pltSizNum > 0) { if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) { - c->rhoFluid = FluidProperties::GetDensityGlycol(state, + c->rhoFluid = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); - c->cpFluid = FluidProperties::GetSpecificHeatGlycol(state, + c->cpFluid = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); } else { // steam loop - c->rhoFluid = FluidProperties::GetSatDensityRefrig(state, + c->rhoFluid = Fluid::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 1.0, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); - c->cpFluid = FluidProperties::GetSatSpecificHeatRefrig(state, + c->cpFluid = Fluid::GetSatSpecificHeatRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 0.0, diff --git a/src/EnergyPlus/RoomAirModelUserTempPattern.cc b/src/EnergyPlus/RoomAirModelUserTempPattern.cc index 6a0738ea74e..e97ff494632 100644 --- a/src/EnergyPlus/RoomAirModelUserTempPattern.cc +++ b/src/EnergyPlus/RoomAirModelUserTempPattern.cc @@ -300,7 +300,7 @@ void FigureHeightPattern(EnergyPlusData &state, int const PattrnID, int const Zo // treat profile as lookup table and interpolate // Using/Aliasing - using FluidProperties::FindArrayIndex; + using Fluid::FindArrayIndex; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: diff --git a/src/EnergyPlus/SetPointManager.cc b/src/EnergyPlus/SetPointManager.cc index 80d0dfaaf40..43c383e07b0 100644 --- a/src/EnergyPlus/SetPointManager.cc +++ b/src/EnergyPlus/SetPointManager.cc @@ -3880,7 +3880,7 @@ void SPMReturnWaterTemp::calculate(EnergyPlusData &state) // fluidIndex = state.dataPlnt->PlantLoop(this->plantLoopNum).FluidIndex; // // we don't need fluid names since we have a real index, so just pass in the temperature and get properties // Real64 const avgTemp = (returnNode.Temp + supplyNode.Temp) / 2; - // Real64 const cp = FluidProperties::GetSpecificHeatGlycol(state, "", avgTemp, fluidIndex, "ReturnWaterChWSetPointManager::calculate"); + // Real64 const cp = Fluid::GetSpecificHeatGlycol(state, "", avgTemp, fluidIndex, "ReturnWaterChWSetPointManager::calculate"); // Real64 const Qdemand = mdot * cp * deltaT; // check for strange conditions diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc index d3a03f22aab..2723fbc4c3d 100644 --- a/src/EnergyPlus/SimulationManager.cc +++ b/src/EnergyPlus/SimulationManager.cc @@ -2616,7 +2616,7 @@ namespace SimulationManager { // Using/Aliasing // using SQLiteProcedures::CreateSQLiteDatabase; - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; state.dataGlobal->DoingInputProcessing = false; diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index d8086e08fa5..5855485f416 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -114,7 +114,6 @@ using HVAC::SmallMassFlow; using namespace DataSizing; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyRhoAirFnPbTdbW; -using namespace FluidProperties; using namespace ScheduleManager; using namespace SteamCoils; @@ -2565,7 +2564,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI this->MassFlowDiff = 1.0e-10 * this->AirMassFlowRateMax; if (this->HWplantLoc.loopNum > 0 && this->ReheatComp_Num != HeatingCoilType::SteamAirHeating) { // protect early calls before plant is setup - rho = GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, @@ -2583,7 +2582,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI if (this->ReheatComp_Num == HeatingCoilType::SteamAirHeating) { SteamTemp = 100.0; - SteamDensity = GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, this->FluidIndex, RoutineNameFull); + SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, this->FluidIndex, RoutineNameFull); this->MaxReheatSteamFlow = SteamDensity * this->MaxReheatSteamVolFlow; this->MinReheatSteamFlow = SteamDensity * this->MinReheatSteamVolFlow; } @@ -2785,8 +2784,8 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) // Obtains flow rates from the zone or system sizing arrays. // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using General::SafeDivide; using PlantUtilities::MyPlantSizingIndex; using SteamCoils::GetCoilSteamInletNode; @@ -3638,10 +3637,10 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS); if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) { TempSteamIn = 100.00; - EnthSteamInDry = GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); - EnthSteamOutWet = GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); + EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); Cp = GetSpecificHeatGlycol(state, fluidNameWater, diff --git a/src/EnergyPlus/SolarCollectors.cc b/src/EnergyPlus/SolarCollectors.cc index ee6437b0bb5..15efc78d5b7 100644 --- a/src/EnergyPlus/SolarCollectors.cc +++ b/src/EnergyPlus/SolarCollectors.cc @@ -937,7 +937,7 @@ namespace SolarCollectors { if (state.dataGlobal->BeginEnvrnFlag && this->Init) { // Clear node initial conditions if (this->VolFlowRateMax > 0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1115,7 +1115,7 @@ namespace SolarCollectors { Real64 massFlowRate = this->MassFlowRate; // Specific heat of collector fluid (J/kg-K) - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1405,14 +1405,14 @@ namespace SolarCollectors { Real64 massFlowRate = this->MassFlowRate; // Specific heat of collector fluid (J/kg-K) - Real64 Cpw = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cpw = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // density of collector fluid (kg/m3) - Real64 Rhow = FluidProperties::GetDensityGlycol(state, + Real64 Rhow = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2049,17 +2049,17 @@ namespace SolarCollectors { Real64 DeltaT = std::abs(TAbsorber - TWater); Real64 TReference = TAbsorber - 0.25 * (TAbsorber - TWater); // record fluid prop index for water - int WaterIndex = FluidProperties::FindGlycol(state, fluidNameWater); + int WaterIndex = Fluid::FindGlycol(state, fluidNameWater); // find properties of water - always assume water - Real64 WaterSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 CondOfWater = FluidProperties::GetConductivityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 VisOfWater = FluidProperties::GetViscosityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 DensOfWater = FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 WaterSpecHeat = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 CondOfWater = Fluid::GetConductivityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 VisOfWater = Fluid::GetViscosityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 DensOfWater = Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); Real64 PrOfWater = VisOfWater * WaterSpecHeat / CondOfWater; // Requires a different reference temperature for volumetric expansion coefficient TReference = TWater - 0.25 * (TWater - TAbsorber); - Real64 VolExpWater = -(FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) + 5.0, WaterIndex, CalledFrom) - - FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) - 5.0, WaterIndex, CalledFrom)) / + Real64 VolExpWater = -(Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) + 5.0, WaterIndex, CalledFrom) - + Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) - 5.0, WaterIndex, CalledFrom)) / (10.0 * DensOfWater); // Grashof number @@ -2116,7 +2116,7 @@ namespace SolarCollectors { PlantUtilities::SafeCopyPlantNode(state, this->InletNode, this->OutletNode); // Set outlet node variables that are possibly changed state.dataLoopNodes->Node(this->OutletNode).Temp = this->OutletTemp; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->OutletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index 846600bf9ad..eddcb2afa26 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -409,8 +409,8 @@ namespace StandardRatings { using namespace OutputReportPredefined; using Curve::CurveValue; using Curve::GetCurveName; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using General::SolveRoot; Real64 constexpr Acc(0.0001); // Accuracy of result diff --git a/src/EnergyPlus/SteamBaseboardRadiator.cc b/src/EnergyPlus/SteamBaseboardRadiator.cc index 5622433861b..fbe8a7a9c94 100644 --- a/src/EnergyPlus/SteamBaseboardRadiator.cc +++ b/src/EnergyPlus/SteamBaseboardRadiator.cc @@ -267,7 +267,7 @@ namespace SteamBaseboardRadiator { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using FluidProperties::FindRefrigerant; + using Fluid::FindRefrigerant; using GlobalNames::VerifyUniqueBaseboardName; using NodeInputManager::GetOnlySingleNode; @@ -909,8 +909,8 @@ namespace SteamBaseboardRadiator { // REFERENCES: // Using/Aliasing - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1069,9 +1069,9 @@ namespace SteamBaseboardRadiator { // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatSpecificHeatRefrig; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatSpecificHeatRefrig; using HVAC::HeatingCapacitySizing; using PlantUtilities::RegisterPlantCompDesignFlow; @@ -1295,9 +1295,9 @@ namespace SteamBaseboardRadiator { // REFERENCES: // Using/Aliasing - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; - using FluidProperties::GetSatSpecificHeatRefrig; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; + using Fluid::GetSatSpecificHeatRefrig; using HVAC::SmallLoad; using ScheduleManager::GetCurrentScheduleValue; diff --git a/src/EnergyPlus/SteamCoils.cc b/src/EnergyPlus/SteamCoils.cc index 05536925037..f028f8ac300 100644 --- a/src/EnergyPlus/SteamCoils.cc +++ b/src/EnergyPlus/SteamCoils.cc @@ -96,7 +96,6 @@ namespace SteamCoils { using namespace DataLoopNode; using namespace Psychrometrics; - using namespace FluidProperties; using PlantUtilities::MyPlantSizingIndex; using PlantUtilities::ScanPlantLoopsForObject; @@ -215,7 +214,7 @@ namespace SteamCoils { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using FluidProperties::FindRefrigerant; + using Fluid::FindRefrigerant; using GlobalNames::VerifyUniqueCoilName; using NodeInputManager::GetOnlySingleNode; @@ -468,8 +467,8 @@ namespace SteamCoils { // na // Using/Aliasing - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; using PlantUtilities::InitComponentNodes; // Locals @@ -664,8 +663,8 @@ namespace SteamCoils { // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetSatDensityRefrig; - using FluidProperties::GetSatEnthalpyRefrig; + using Fluid::GetSatDensityRefrig; + using Fluid::GetSatEnthalpyRefrig; using PlantUtilities::RegisterPlantCompDesignFlow; // SUBROUTINE PARAMETER DEFINITIONS: @@ -828,7 +827,7 @@ namespace SteamCoils { // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'SizeSteamCoil') - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate = @@ -897,7 +896,7 @@ namespace SteamCoils { // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'SizeSteamCoil') - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate = @@ -1118,9 +1117,9 @@ namespace SteamCoils { // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. EnthSteamInDry = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); EnthSteamOutWet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; @@ -1129,7 +1128,7 @@ namespace SteamCoils { // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'CalcSteamAirCoil') - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Max Heat Transfer @@ -1181,7 +1180,7 @@ namespace SteamCoils { // considering saturated state. // StdBaroPress=101325 - TempWaterAtmPress = GetSatTemperatureRefrig( + TempWaterAtmPress = Fluid::GetSatTemperatureRefrig( state, fluidNameSteam, state.dataEnvrn->StdBaroPress, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Point 4 at atm - loop delta subcool during return journery back to pump @@ -1189,15 +1188,15 @@ namespace SteamCoils { // Actual Steam Coil Outlet Enthalpy EnthCoilOutlet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - CpWater * SubcoolDeltaTemp; // Enthalpy at Point 4 - EnthAtAtmPress = GetSatEnthalpyRefrig( + EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, TempWaterAtmPress, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Reported value of coil outlet enthalpy at the node to match the node outlet temperature - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempLoopOutToPump, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); EnthPumpInlet = EnthAtAtmPress - CpWater * state.dataSteamCoils->SteamCoil(CoilNum).LoopSubcoolReturn; @@ -1233,16 +1232,16 @@ namespace SteamCoils { // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. EnthSteamInDry = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); EnthSteamOutWet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; // CpWater = GetSpecificHeatGlycol('WATER', & // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'CalcSteamAirCoil') - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Max Heat Transfer @@ -1353,22 +1352,22 @@ namespace SteamCoils { // considering saturated state. // StdBaroPress=101325 - TempWaterAtmPress = GetSatTemperatureRefrig( + TempWaterAtmPress = Fluid::GetSatTemperatureRefrig( state, fluidNameSteam, state.dataEnvrn->StdBaroPress, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Point 4 at atm - loop delta subcool during return journery back to pump TempLoopOutToPump = TempWaterAtmPress - state.dataSteamCoils->SteamCoil(CoilNum).LoopSubcoolReturn; // Actual Steam Coil Outlet Enthalpy - EnthCoilOutlet = GetSatEnthalpyRefrig( + EnthCoilOutlet = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - CpWater * SubcoolDeltaTemp; // Enthalpy at Point 4 - EnthAtAtmPress = GetSatEnthalpyRefrig( + EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, TempWaterAtmPress, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); - CpWater = GetSatSpecificHeatRefrig( + CpWater = Fluid::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempLoopOutToPump, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Reported value of coil outlet enthalpy at the node to match the node outlet temperature diff --git a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc index 1acd036b83d..9939e1b8d57 100644 --- a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc +++ b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc @@ -183,8 +183,8 @@ namespace SurfaceGroundHeatExchanger { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using FluidProperties::CheckFluidPropertyName; - using FluidProperties::FindGlycol; + using Fluid::CheckFluidPropertyName; + using Fluid::FindGlycol; using NodeInputManager::GetOnlySingleNode; using namespace DataLoopNode; @@ -1078,7 +1078,7 @@ namespace SurfaceGroundHeatExchanger { // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; // Return value Real64 CalcHXEffectTerm; @@ -1346,7 +1346,7 @@ namespace SurfaceGroundHeatExchanger { // Using/Aliasing Real64 SysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed; Real64 TimeStepSys = state.dataHVACGlobal->TimeStepSys; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1434,7 +1434,7 @@ namespace SurfaceGroundHeatExchanger { void SurfaceGroundHeatExchangerData::oneTimeInit_new(EnergyPlusData &state) { - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::RegisterPlantCompDesignFlow; using PlantUtilities::ScanPlantLoopsForObject; diff --git a/src/EnergyPlus/SwimmingPool.cc b/src/EnergyPlus/SwimmingPool.cc index ca74f2ae0a9..bf4eb26a9c3 100644 --- a/src/EnergyPlus/SwimmingPool.cc +++ b/src/EnergyPlus/SwimmingPool.cc @@ -510,7 +510,7 @@ void SwimmingPoolData::initialize(EnergyPlusData &state, bool const FirstHVACIte this->WaterOutletTemp = 0.0; this->WaterMassFlowRate = 0.0; this->PeopleHeatGain = 0.0; - Real64 Density = FluidProperties::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); + Real64 Density = Fluid::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); this->WaterMass = state.dataSurface->Surface(this->SurfacePtr).Area * this->AvgDepth * Density; this->WaterMassFlowRateMax = this->WaterVolFlowMax * Density; this->initSwimmingPoolPlantNodeFlow(state); @@ -917,7 +917,7 @@ void SwimmingPoolData::calculate(EnergyPlusData &state) // Get an estimate of the pool water specific heat Real64 Cp = - FluidProperties::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of pool water + Fluid::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of pool water Real64 TH22 = state.dataHeatBalSurf->SurfInsideTempHist(2)( SurfNum); // inside surface temperature at the previous time step equals the old pool water temperature @@ -1050,12 +1050,12 @@ void SwimmingPoolData::report(EnergyPlusData &state) this->PoolWaterTemp = state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum); // Next calculate the amount of heating done by the plant loop - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of water this->HeatPower = this->WaterMassFlowRate * Cp * (this->WaterInletTemp - this->PoolWaterTemp); // Now the power consumption of miscellaneous equipment - Real64 Density = FluidProperties::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, + Real64 Density = Fluid::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // density of water if (Density > MinDensity) { this->MiscEquipPower = this->MiscPowerFactor * this->WaterMassFlowRate / Density; diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc index c93ef135ae0..05cee954296 100644 --- a/src/EnergyPlus/UnitHeater.cc +++ b/src/EnergyPlus/UnitHeater.cc @@ -120,7 +120,6 @@ namespace UnitHeater { using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyRhoAirFnPbTdbW; - using namespace FluidProperties; static constexpr std::string_view fluidNameSteam("STEAM"); @@ -659,7 +658,7 @@ namespace UnitHeater { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -784,7 +783,7 @@ namespace UnitHeater { } if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) { TempSteamIn = 100.00; - SteamDensity = GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_FluidIndex, RoutineName); state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotSteamFlow = SteamDensity * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow; @@ -1139,13 +1138,13 @@ namespace UnitHeater { } if (DesCoilLoad >= SmallLoad) { - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, RoutineName); - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -1270,12 +1269,12 @@ namespace UnitHeater { if (DesCoilLoad >= SmallLoad) { TempSteamIn = 100.00; EnthSteamInDry = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); EnthSteamOutWet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; SteamDensity = - GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); MaxVolHotSteamFlowDes = DesCoilLoad / (SteamDensity * (LatentHeatSteam + state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * CPHW(state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp))); diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc index 6e72faa07bc..04cb120f742 100644 --- a/src/EnergyPlus/UnitVentilator.cc +++ b/src/EnergyPlus/UnitVentilator.cc @@ -1127,7 +1127,7 @@ namespace UnitVentilator { if (unitVent.HCoilType == HeatCoilType::Water) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, @@ -1142,7 +1142,7 @@ namespace UnitVentilator { if (unitVent.HCoilType == HeatCoilType::Steam) { Real64 TempSteamIn = 100.00; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, unitVent.HCoil_FluidIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, unitVent.HCoil_FluidIndex, RoutineName); unitVent.MaxHotSteamFlow = SteamDensity * unitVent.MaxVolHotSteamFlow; unitVent.MinHotSteamFlow = SteamDensity * unitVent.MinVolHotSteamFlow; @@ -1152,7 +1152,7 @@ namespace UnitVentilator { } //(UnitVent(UnitVentNum)%HCoilPresent) if (unitVent.CCoilPresent) { // Only initialize these if a cooling coil is actually present - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, @@ -1881,12 +1881,12 @@ namespace UnitVentilator { sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesHeatingLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, @@ -2012,14 +2012,14 @@ namespace UnitVentilator { DesHeatingLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound); } TempSteamIn = 100.00; - EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + EnthSteamInDry = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitVentilators->RefrigIndex, RoutineName); - EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitVentilators->RefrigIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = FluidProperties::GetSatDensityRefrig( + SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitVentilators->RefrigIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, state.dataUnitVentilators->DummyWaterIndex, @@ -2170,12 +2170,12 @@ namespace UnitVentilator { sizerCoolingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesCoolingLoad = sizerCoolingCapacity.size(state, TempSize, ErrorsFound); } - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index cb772fa38b5..07967395c02 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -589,7 +589,7 @@ namespace UnitarySystems { state, CoolingCoilType, CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxCoolCoilFluidFlow > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidIndex, @@ -636,7 +636,7 @@ namespace UnitarySystems { state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxHeatCoilFluidFlow > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -652,7 +652,7 @@ namespace UnitarySystems { if (this->MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow *= SteamDensity; } } @@ -692,7 +692,7 @@ namespace UnitarySystems { state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->m_MaxSuppCoilFluidFlow > 0.0) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -725,7 +725,7 @@ namespace UnitarySystems { if (this->m_MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow *= SteamDensity; } @@ -764,7 +764,7 @@ namespace UnitarySystems { if ((this->m_HeatRecActive) && (!this->m_MyPlantScanFlag)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidIndex, @@ -790,7 +790,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, CoolingCoilType, this->m_CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidIndex, @@ -811,7 +811,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -834,7 +834,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -851,7 +851,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -873,7 +873,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -4359,7 +4359,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); this->MaxHeatCoilFluidFlow *= SteamDensity; errFlag = false; } @@ -5379,7 +5379,7 @@ namespace UnitarySystems { if (this->m_MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( + Real64 SteamDensity = Fluid::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); this->m_MaxSuppCoilFluidFlow = this->m_MaxSuppCoilFluidFlow * SteamDensity; } @@ -9998,7 +9998,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_HeatingCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -10019,7 +10019,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -10036,7 +10036,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_SuppHeatCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -10056,7 +10056,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -15724,7 +15724,7 @@ namespace UnitarySystems { if (HeatRecMassFlowRate > 0.0) { - Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidName, HeatRecInletTemp, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/UserDefinedComponents.cc b/src/EnergyPlus/UserDefinedComponents.cc index edce549a41f..2d70b6c875f 100644 --- a/src/EnergyPlus/UserDefinedComponents.cc +++ b/src/EnergyPlus/UserDefinedComponents.cc @@ -2429,13 +2429,13 @@ namespace UserDefinedComponents { // fill internal variable targets this->Loop(LoopNum).MyLoad = MyLoad; - this->Loop(LoopNum).InletRho = FluidProperties::GetDensityGlycol(state, + this->Loop(LoopNum).InletRho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(LoopNum).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(LoopNum).InletCp = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(LoopNum).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidIndex, @@ -2498,12 +2498,12 @@ namespace UserDefinedComponents { } if (this->PlantIsConnected) { - this->Loop.InletRho = FluidProperties::GetDensityGlycol(state, + this->Loop.InletRho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop.InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidIndex, RoutineName); - this->Loop.InletCp = FluidProperties::GetSpecificHeatGlycol(state, + this->Loop.InletCp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop.InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidIndex, @@ -2581,13 +2581,13 @@ namespace UserDefinedComponents { if (this->NumPlantConnections > 0) { for (int loop = 1; loop <= this->NumPlantConnections; ++loop) { - this->Loop(loop).InletRho = FluidProperties::GetDensityGlycol(state, + this->Loop(loop).InletRho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(loop).InletCp = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, @@ -2663,13 +2663,13 @@ namespace UserDefinedComponents { if (this->NumPlantConnections > 0) { for (int loop = 1; loop <= this->NumPlantConnections; ++loop) { - this->Loop(loop).InletRho = FluidProperties::GetDensityGlycol(state, + this->Loop(loop).InletRho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(loop).InletCp = - FluidProperties::GetSpecificHeatGlycol(state, + Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/VariableSpeedCoils.cc b/src/EnergyPlus/VariableSpeedCoils.cc index 82a15c38b25..b35ff54ba90 100644 --- a/src/EnergyPlus/VariableSpeedCoils.cc +++ b/src/EnergyPlus/VariableSpeedCoils.cc @@ -139,7 +139,7 @@ namespace VariableSpeedCoils { // This subroutine manages variable-speed Water to Air Heat Pump component simulation. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; using General::SolveRoot; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: @@ -3880,8 +3880,8 @@ namespace VariableSpeedCoils { // Uses the status flags to trigger initializations. // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -5283,12 +5283,12 @@ namespace VariableSpeedCoils { false); if (PltSizNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, RoutineNameAlt); - cp = FluidProperties::GetSpecificHeatGlycol(state, + cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, @@ -5426,7 +5426,7 @@ namespace VariableSpeedCoils { if (PltSizNum > 0) { rhoW = rho; } else { - rhoW = FluidProperties::GetDensityGlycol(state, + rhoW = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, RatedSourceTempCool, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, @@ -5874,7 +5874,7 @@ namespace VariableSpeedCoils { // Using/Aliasing using Curve::CurveValue; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyRhoAirFnPbTdbW; @@ -7236,7 +7236,7 @@ namespace VariableSpeedCoils { // Using/Aliasing using Curve::CurveValue; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyRhoAirFnPbTdbW; @@ -7747,7 +7747,7 @@ namespace VariableSpeedCoils { // as negative. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value Real64 CoilCapacity; // returned capacity of matched coil @@ -7809,7 +7809,7 @@ namespace VariableSpeedCoils { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int IndexNum; // returned index of matched coil @@ -7992,7 +7992,7 @@ namespace VariableSpeedCoils { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int NodeNumber; // returned outlet node of matched coil @@ -8040,7 +8040,7 @@ namespace VariableSpeedCoils { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int NodeNumber; // returned outlet node of matched coil @@ -8217,7 +8217,7 @@ namespace VariableSpeedCoils { // this WSHP coil object. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index 6fccd5a9419..893dc0220f7 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -124,7 +124,6 @@ namespace VentilatedSlab { using HVAC::SmallAirVolFlow; using namespace ScheduleManager; using namespace Psychrometrics; - using namespace FluidProperties; static std::string const fluidNameSteam("STEAM"); static std::string const fluidNameWater("WATER"); @@ -235,7 +234,7 @@ namespace VentilatedSlab { using namespace DataLoopNode; using namespace DataSurfaceLists; - using FluidProperties::FindRefrigerant; + using Fluid::FindRefrigerant; using OutAirNodeManager::CheckAndAddAirNodeNumber; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1493,7 +1492,7 @@ namespace VentilatedSlab { auto &ventSlab = state.dataVentilatedSlab->VentSlab(Item); using DataZoneEquipment::CheckZoneEquipmentList; - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using ScheduleManager::GetCurrentScheduleValue; @@ -1682,7 +1681,7 @@ namespace VentilatedSlab { if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) { TempSteamIn = 100.00; - SteamDensity = GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); ventSlab.MaxHotSteamFlow = SteamDensity * ventSlab.MaxVolHotSteamFlow; ventSlab.MinHotSteamFlow = SteamDensity * ventSlab.MinVolHotSteamFlow; @@ -1790,8 +1789,8 @@ namespace VentilatedSlab { // Using/Aliasing using namespace DataSizing; - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using HVAC::CoolingCapacitySizing; using HVAC::HeatingAirflowSizing; using HVAC::HeatingCapacitySizing; @@ -2320,12 +2319,12 @@ namespace VentilatedSlab { } TempSteamIn = 100.00; EnthSteamInDry = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); EnthSteamOutWet = - GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; SteamDensity = - GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); Cp = GetSpecificHeatGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); rho = GetDensityGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); MaxVolHotSteamFlowDes = diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc index b488f4fb3ca..4aae6b48349 100644 --- a/src/EnergyPlus/WaterCoils.cc +++ b/src/EnergyPlus/WaterCoils.cc @@ -121,8 +121,8 @@ namespace EnergyPlus::WaterCoils { using namespace DataLoopNode; -using FluidProperties::GetDensityGlycol; -using FluidProperties::GetSpecificHeatGlycol; +using Fluid::GetDensityGlycol; +using Fluid::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbRhPb; using Psychrometrics::PsyHFnTdbW; diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc index 730b4f5ddad..18ca280aae4 100644 --- a/src/EnergyPlus/WaterThermalTanks.cc +++ b/src/EnergyPlus/WaterThermalTanks.cc @@ -2589,7 +2589,7 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state) Tank.OnCycLossCoeff = state.dataIPShortCut->rNumericArgs(15); Tank.OnCycLossFracToZone = state.dataIPShortCut->rNumericArgs(16); - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(17) * rho; if ((state.dataIPShortCut->cAlphaArgs(14).empty()) && (state.dataIPShortCut->cAlphaArgs(15).empty())) { @@ -2828,7 +2828,7 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state) if (Tank.Volume == DataSizing::AutoSize) { Tank.VolumeWasAutoSized = true; } - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.Mass = Tank.Volume * rho; Tank.Height = state.dataIPShortCut->rNumericArgs(2); if (Tank.Height == DataSizing::AutoSize) { @@ -3132,7 +3132,7 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state) Tank.OffCycFlueLossFracToZone = state.dataIPShortCut->rNumericArgs(21); // this is temporary until we know fluid type - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(22) * rho; if ((state.dataIPShortCut->cAlphaArgs(16).empty()) && (state.dataIPShortCut->cAlphaArgs(17).empty())) { @@ -3766,7 +3766,7 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state) if (Tank.Volume == DataSizing::AutoSize) { Tank.VolumeWasAutoSized = true; } - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.Mass = Tank.Volume * rho; Tank.Height = state.dataIPShortCut->rNumericArgs(2); if (Tank.Height == DataSizing::AutoSize) { @@ -5800,13 +5800,13 @@ void WaterThermalTankData::SetupStratifiedNodes(EnergyPlusData &state) this->Node.allocate(NumNodes); Real64 rho; if ((this->UseSidePlantLoc.loopNum > 0) && allocated(state.dataPlnt->PlantLoop)) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, RoutineName); } Real64 NodeMass = this->Volume * rho / NumNodes; @@ -6058,7 +6058,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA if (this->SetLoopIndexFlag && allocated(state.dataPlnt->PlantLoop)) { if ((this->UseInletNode > 0) && (this->HeatPumpNum == 0)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6073,7 +6073,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->UseInletNode > 0) && (this->HeatPumpNum > 0)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6088,7 +6088,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -6153,7 +6153,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA // Clear node initial conditions if (this->UseInletNode > 0 && this->UseOutletNode > 0) { state.dataLoopNodes->Node(this->UseInletNode).Temp = 0.0; - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6170,7 +6170,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -6190,7 +6190,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA this->SourceOutletTemp = 0.0; this->SourceMassFlowRate = 0.0; this->SavedSourceOutletTemp = 0.0; - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, SizeTankForDemand); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, SizeTankForDemand); this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } @@ -6835,26 +6835,26 @@ void WaterThermalTankData::CalcWaterThermalTankMixed(EnergyPlusData &state) // W Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, TankTemp_loc, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); } Real64 TankMass = rho * this->Volume; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, TankTemp_loc, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); } Real64 SecInTimeStep = state.dataHVACGlobal->TimeStepSysSec; @@ -7736,13 +7736,13 @@ void WaterThermalTankData::CalcWaterThermalTankStratified(EnergyPlusData &state) // Specific Heat of water (J/kg K) const Real64 Cp = [&] { if (this->UseSidePlantLoc.loopNum > 0) { - return FluidProperties::GetSpecificHeatGlycol(state, + return Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, this->TankTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - return FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, this->TankTemp, this->waterIndex, RoutineName); + return Fluid::GetSpecificHeatGlycol(state, fluidNameWater, this->TankTemp, this->waterIndex, RoutineName); } }(); @@ -10720,7 +10720,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -10738,13 +10738,13 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; @@ -10783,7 +10783,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -10802,13 +10802,13 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } @@ -11015,19 +11015,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = SumPeopleAllZones * this->Sizing.RecoveryCapacityPerPerson * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * @@ -11066,19 +11066,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = SumFloorAreaAllZones * this->Sizing.RecoveryCapacityPerArea * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m2 | m3/hr/m2 | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k @@ -11111,19 +11111,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = this->Sizing.NumberOfUnits * this->Sizing.RecoveryCapacityPerUnit * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/ea | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k @@ -11224,19 +11224,19 @@ void WaterThermalTankData::SizeTankForSupplySide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = (this->Volume * rho * Cp * (Tfinish - Tstart)) / (this->Sizing.RecoveryTime * Constant::SecInHour); // m3 | kg/m3 | J/Kg/K | K | seconds @@ -11402,7 +11402,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -11422,13 +11422,13 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; } // autosizing needed. @@ -11490,7 +11490,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = FluidProperties::GetDensityGlycol(state, + Real64 rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -11510,13 +11510,13 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } // autosizing needed. @@ -11558,7 +11558,7 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) case SizingMode::PeakDraw: { // get draw rate from maximum in schedule - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); Real64 DrawDesignVolFlowRate = ScheduleManager::GetScheduleMaxValue(state, this->FlowRateSchedule) * this->MassFlowRateMax / rho; if (this->VolumeWasAutoSized) { @@ -11568,9 +11568,9 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) } if (this->MaxCapacityWasAutoSized) { if (this->Sizing.RecoveryTime > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); Real64 Cp = - FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = (this->Volume * rho * Cp * (Tfinish - Tstart)) / (this->Sizing.RecoveryTime * Constant::SecInHour); // m3 | kg/m3 | J/Kg/K | K | seconds @@ -11734,8 +11734,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) tmpTankVolume = this->Sizing.TankCapacityPerPerson * SumPeopleAllZones; } if (this->MaxCapacityWasAutoSized) { - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = SumPeopleAllZones * this->Sizing.RecoveryCapacityPerPerson * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/person | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } @@ -11763,8 +11763,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) } if (this->MaxCapacityWasAutoSized) { - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = SumFloorAreaAllZones * this->Sizing.RecoveryCapacityPerArea * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m2 | m3/hr/m2 | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } @@ -11783,8 +11783,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) if (this->VolumeWasAutoSized) tmpTankVolume = this->Sizing.TankCapacityPerUnit * this->Sizing.NumberOfUnits; if (this->MaxCapacityWasAutoSized) { - Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = this->Sizing.NumberOfUnits * this->Sizing.RecoveryCapacityPerUnit * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/ea | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } diff --git a/src/EnergyPlus/WaterToAirHeatPump.cc b/src/EnergyPlus/WaterToAirHeatPump.cc index 30124197e5d..e070b12bdad 100644 --- a/src/EnergyPlus/WaterToAirHeatPump.cc +++ b/src/EnergyPlus/WaterToAirHeatPump.cc @@ -121,7 +121,7 @@ namespace WaterToAirHeatPump { // This subroutine manages Water to Air Heat Pump component simulation. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // shut off after compressor cycle off [s] // cycling fan/cycling compressor @@ -203,8 +203,8 @@ namespace WaterToAirHeatPump { // Using/Aliasing using namespace NodeInputManager; using BranchNodeConnections::TestCompSet; - using FluidProperties::CheckFluidPropertyName; - using FluidProperties::FindGlycol; + using Fluid::CheckFluidPropertyName; + using Fluid::FindGlycol; using GlobalNames::VerifyUniqueCoilName; using PlantUtilities::RegisterPlantCompDesignFlow; using namespace OutputReportPredefined; @@ -996,8 +996,8 @@ namespace WaterToAirHeatPump { // Uses the status flags to trigger initializations. // Using/Aliasing - using FluidProperties::GetDensityGlycol; - using FluidProperties::GetSpecificHeatGlycol; + using Fluid::GetDensityGlycol; + using Fluid::GetSpecificHeatGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -1225,7 +1225,6 @@ namespace WaterToAirHeatPump { // Simulates a parameter estimation based water to air heat pump model // Using/Aliasing - using namespace FluidProperties; using General::SolveRoot; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; // ,PsyHFnTdbRhPb,PsyWFnTdpPb @@ -1332,7 +1331,7 @@ namespace WaterToAirHeatPump { SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / - GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + Fluid::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); StillSimulatingFlag = true; @@ -1438,7 +1437,7 @@ namespace WaterToAirHeatPump { } // Determine Effectiveness of Source Side - CpFluid = GetSpecificHeatGlycol( + CpFluid = Fluid::GetSpecificHeatGlycol( state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // IF (SourceSideFluidName=='WATER') THEN @@ -1495,9 +1494,9 @@ namespace WaterToAirHeatPump { LoadSideTemp = EvapTemp; // Determine the Load Side and Source Side Saturated Temp (evaporating and condensing pressures) - SourceSidePressure = GetSatPressureRefrig( + SourceSidePressure = Fluid::GetSatPressureRefrig( state, heatPump.Refrigerant, SourceSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); - LoadSidePressure = GetSatPressureRefrig( + LoadSidePressure = Fluid::GetSatPressureRefrig( state, heatPump.Refrigerant, LoadSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); if (LoadSidePressure < heatPump.LowPressCutoff && !FirstHVACIteration) { @@ -1547,18 +1546,18 @@ namespace WaterToAirHeatPump { // Determine the Load Side Outlet Enthalpy (Saturated Gas) Quality = 1.0; - LoadSideOutletEnth = GetSatEnthalpyRefrig( + LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, LoadSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); // Determine Source Side Outlet Enthalpy (Saturated Liquid) Quality = 0.0; - SourceSideOutletEnth = GetSatEnthalpyRefrig( + SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, SourceSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); // Determine Superheated Temperature of the Load Side outlet/compressor Inlet CompressInletTemp = LoadSideTemp + heatPump.SuperheatTemp; // Determine the Enthalpy of the Superheated Fluid at Load Side Outlet/Compressor Inlet - SuperHeatEnth = GetSupHeatEnthalpyRefrig(state, + SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, CompressInletTemp, LoadSidePressure, @@ -1570,7 +1569,7 @@ namespace WaterToAirHeatPump { // Determine the saturated temp at suction pressure, shoot out into the superheated region find the enthalpy // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached if (!Converged) { - CompSuctionSatTemp = GetSatTemperatureRefrig( + CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( state, heatPump.Refrigerant, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSuctionPr); CompSuctionTemp1 = CompSuctionSatTemp; @@ -1582,7 +1581,7 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -1592,13 +1591,13 @@ namespace WaterToAirHeatPump { heatPump.SimFlag = false; return; } - CompSuctionEnth = GetSupHeatEnthalpyRefrig(state, + CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, state.dataWaterToAirHeatPump->CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); - CompSuctionDensity = GetSupHeatDensityRefrig(state, + CompSuctionDensity = Fluid::GetSupHeatDensityRefrig(state, heatPump.Refrigerant, state.dataWaterToAirHeatPump->CompSuctionTemp, SuctionPr, @@ -1759,7 +1758,6 @@ namespace WaterToAirHeatPump { // Simulates a parameter estimation based water to air heat pump model // Using/Aliasing - using namespace FluidProperties; using General::SolveRoot; using Psychrometrics::PsyCpAirFnW; // ,PsyHFnTdbRhPb,PsyWFnTdpPb using Psychrometrics::PsyTdbFnHW; @@ -1848,7 +1846,7 @@ namespace WaterToAirHeatPump { SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / - GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + Fluid::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // If heat pump is not operating, return if (SensDemand == 0.0 || heatPump.InletAirMassFlowRate <= 0.0 || heatPump.InletWaterMassFlowRate <= 0.0) { @@ -1908,7 +1906,7 @@ namespace WaterToAirHeatPump { // Determine Effectiveness of Source Side CpFluid = - GetSpecificHeatGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + Fluid::GetSpecificHeatGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // IF (SourceSideFluidName=='WATER') THEN if (SourceSideFluidIndex == state.dataWaterToAirHeatPump->WaterIndex) { @@ -1928,9 +1926,9 @@ namespace WaterToAirHeatPump { LoadSideTemp = heatPump.InletAirDBTemp + state.dataWaterToAirHeatPump->initialQLoad * LoadSideEffect_CpAir_MassFlowRate_inv; // Determine the Load Side and Source Side Saturated Temp (evaporating and condensing pressures) - SourceSidePressure = GetSatPressureRefrig( + SourceSidePressure = Fluid::GetSatPressureRefrig( state, heatPump.Refrigerant, SourceSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); - LoadSidePressure = GetSatPressureRefrig( + LoadSidePressure = Fluid::GetSatPressureRefrig( state, heatPump.Refrigerant, LoadSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); if (SourceSidePressure < heatPump.LowPressCutoff && !FirstHVACIteration) { if (!state.dataGlobal->WarmupFlag) { @@ -1993,20 +1991,20 @@ namespace WaterToAirHeatPump { // Determine the Source Side Outlet Enthalpy // Quality of the refrigerant leaving the evaporator is saturated gas Quality = 1.0; - SourceSideOutletEnth = GetSatEnthalpyRefrig( + SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, SourceSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); // Determine Load Side Outlet Enthalpy // Quality of the refrigerant leaving the condenser is saturated liguid Quality = 0.0; - LoadSideOutletEnth = GetSatEnthalpyRefrig( + LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, LoadSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); // Determine Superheated Temperature of the Source Side outlet/compressor Inlet CompressInletTemp = SourceSideTemp + heatPump.SuperheatTemp; // Determine the Enathalpy of the Superheated Fluid at Source Side Outlet/Compressor Inlet - SuperHeatEnth = GetSupHeatEnthalpyRefrig(state, + SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, CompressInletTemp, SourceSidePressure, @@ -2019,7 +2017,7 @@ namespace WaterToAirHeatPump { // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached if (!Converged) { - CompSuctionSatTemp = GetSatTemperatureRefrig( + CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( state, heatPump.Refrigerant, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSuctionPr); CompSuctionTemp1 = CompSuctionSatTemp; @@ -2054,7 +2052,7 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -2063,9 +2061,9 @@ namespace WaterToAirHeatPump { heatPump.SimFlag = false; return; } - CompSuctionEnth = GetSupHeatEnthalpyRefrig( + CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( state, heatPump.Refrigerant, CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); - CompSuctionDensity = GetSupHeatDensityRefrig( + CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( state, heatPump.Refrigerant, CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); // Find Refrigerant Flow Rate @@ -2427,9 +2425,6 @@ namespace WaterToAirHeatPump { // Jin, H. 2002. Parameter Estimation Based Models of Water Source Heat Pumps. Phd Thesis. // Oklahoma State University. - // Using/Aliasing - using namespace FluidProperties; - // Return value Real64 DegradF; @@ -2447,14 +2442,14 @@ namespace WaterToAirHeatPump { Real64 CpCoolant; // Specific heat of water [J/kg-K] Real64 CondCoolant; // Conductivity of water [W/m-K] - VisWater = GetViscosityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - DensityWater = GetDensityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - CpWater = GetSpecificHeatGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - CondWater = GetConductivityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - VisCoolant = GetViscosityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - DensityCoolant = GetDensityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - CpCoolant = GetSpecificHeatGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - CondCoolant = GetConductivityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + VisWater = Fluid::GetViscosityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + DensityWater = Fluid::GetDensityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + CpWater = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + CondWater = Fluid::GetConductivityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + VisCoolant = Fluid::GetViscosityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + DensityCoolant = Fluid::GetDensityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + CpCoolant = Fluid::GetSpecificHeatGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + CondCoolant = Fluid::GetConductivityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); DegradF = std::pow(VisCoolant / VisWater, -0.47) * std::pow(DensityCoolant / DensityWater, 0.8) * std::pow(CpCoolant / CpWater, 0.33) * std::pow(CondCoolant / CondWater, 0.67); @@ -2481,7 +2476,7 @@ namespace WaterToAirHeatPump { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int IndexNum; // returned index of matched coil @@ -2522,7 +2517,7 @@ namespace WaterToAirHeatPump { // as negative. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value Real64 CoilCapacity; // returned capacity of matched coil @@ -2579,7 +2574,7 @@ namespace WaterToAirHeatPump { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int NodeNumber; // returned outlet node of matched coil @@ -2627,7 +2622,7 @@ namespace WaterToAirHeatPump { // as zero. // Using/Aliasing - using FluidProperties::FindGlycol; + using Fluid::FindGlycol; // Return value int NodeNumber; // returned outlet node of matched coil diff --git a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc index 4da0dc01b80..3d3a091e9ff 100644 --- a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc +++ b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc @@ -1126,7 +1126,7 @@ namespace WaterToAirHeatPumpSimple { simpleWatertoAirHP.PartLoadRatio = 0.0; if (simpleWatertoAirHP.RatedWaterVolFlowRate != DataSizing::AutoSize) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -2865,12 +2865,12 @@ namespace WaterToAirHeatPumpSimple { false); if (PltSizNum > 0) { - rho = FluidProperties::GetDensityGlycol(state, + rho = Fluid::GetDensityGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, RoutineNameAlt); - Cp = FluidProperties::GetSpecificHeatGlycol(state, + Cp = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -3097,7 +3097,7 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = FluidProperties::GetSpecificHeatGlycol(state, + CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -3399,7 +3399,7 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = FluidProperties::GetSpecificHeatGlycol(state, + CpWater = Fluid::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/WaterUse.cc b/src/EnergyPlus/WaterUse.cc index 9d3a86681f6..46d87616c28 100644 --- a/src/EnergyPlus/WaterUse.cc +++ b/src/EnergyPlus/WaterUse.cc @@ -1702,7 +1702,7 @@ namespace WaterUse { if (state.dataWaterUse->calcRhoH2O) { int DummyValue = 1; - state.dataWaterUse->rhoH2OStd = FluidProperties::GetDensityGlycol(state, "WATER", Constant::InitConvTemp, DummyValue, RoutineName); + state.dataWaterUse->rhoH2OStd = Fluid::GetDensityGlycol(state, "WATER", Constant::InitConvTemp, DummyValue, RoutineName); state.dataWaterUse->calcRhoH2O = false; } return state.dataWaterUse->rhoH2OStd; diff --git a/src/EnergyPlus/api/EnergyPlusPgm.cc b/src/EnergyPlus/api/EnergyPlusPgm.cc index a86e8c1a94e..6fc0c2ef5d2 100644 --- a/src/EnergyPlus/api/EnergyPlusPgm.cc +++ b/src/EnergyPlus/api/EnergyPlusPgm.cc @@ -360,7 +360,7 @@ int wrapUpEnergyPlus(EnergyPlus::EnergyPlusData &state) Psychrometrics::ShowPsychrometricSummary(state, state.files.audit); state.dataInputProcessing->inputProcessor->reportOrphanRecordObjects(state); - FluidProperties::ReportOrphanFluids(state); + Fluid::ReportOrphanFluids(state); ScheduleManager::ReportOrphanSchedules(state); if (state.dataSQLiteProcedures->sqlite) { state.dataSQLiteProcedures->sqlite.reset(); diff --git a/src/EnergyPlus/api/func.cc b/src/EnergyPlus/api/func.cc index c17d244fb16..4136e0675e8 100644 --- a/src/EnergyPlus/api/func.cc +++ b/src/EnergyPlus/api/func.cc @@ -62,7 +62,7 @@ void initializeFunctionalAPI(EnergyPlusState state) thisState->dataInputProcessing->inputProcessor = EnergyPlus::InputProcessor::factory(); } EnergyPlus::Psychrometrics::InitializePsychRoutines(*thisState); - EnergyPlus::FluidProperties::InitializeGlycRoutines(); + EnergyPlus::Fluid::InitializeGlycRoutines(); } const char *apiVersionFromEPlus(EnergyPlusState) @@ -89,68 +89,68 @@ void registerErrorCallback(EnergyPlusState state, void (*f)(int, const char *)) Glycol glycolNew(EnergyPlusState state, const char *glycolName) { auto *thisState = reinterpret_cast(state); - auto *glycol = new EnergyPlus::FluidProperties::GlycolAPI(*thisState, glycolName); + auto *glycol = new EnergyPlus::Fluid::GlycolAPI(*thisState, glycolName); return reinterpret_cast(glycol); } void glycolDelete(EnergyPlusState, Glycol glycol) { - delete reinterpret_cast(glycol); + delete reinterpret_cast(glycol); } Real64 glycolSpecificHeat(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->specificHeat(*thisState, temperature); + return reinterpret_cast(glycol)->specificHeat(*thisState, temperature); } Real64 glycolDensity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->density(*thisState, temperature); + return reinterpret_cast(glycol)->density(*thisState, temperature); } Real64 glycolConductivity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->conductivity(*thisState, temperature); + return reinterpret_cast(glycol)->conductivity(*thisState, temperature); } Real64 glycolViscosity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->viscosity(*thisState, temperature); + return reinterpret_cast(glycol)->viscosity(*thisState, temperature); } Refrigerant refrigerantNew(EnergyPlusState state, const char *refrigerantName) { auto *thisState = reinterpret_cast(state); - auto *refrigerant = new EnergyPlus::FluidProperties::RefrigerantAPI(*thisState, refrigerantName); + auto *refrigerant = new EnergyPlus::Fluid::RefrigerantAPI(*thisState, refrigerantName); return reinterpret_cast(refrigerant); } void refrigerantDelete(EnergyPlusState, Refrigerant refrigerant) { - delete reinterpret_cast(refrigerant); + delete reinterpret_cast(refrigerant); } Real64 refrigerantSaturationPressure(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturationPressure(*thisState, temperature); + return reinterpret_cast(refrigerant)->saturationPressure(*thisState, temperature); } Real64 refrigerantSaturationTemperature(EnergyPlusState state, Refrigerant refrigerant, Real64 pressure) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturationTemperature(*thisState, pressure); + return reinterpret_cast(refrigerant)->saturationTemperature(*thisState, pressure); } Real64 refrigerantSaturatedEnthalpy(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedEnthalpy(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedEnthalpy(*thisState, temperature, quality); } Real64 refrigerantSaturatedDensity(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedDensity(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedDensity(*thisState, temperature, quality); } Real64 refrigerantSaturatedSpecificHeat(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedSpecificHeat(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedSpecificHeat(*thisState, temperature, quality); } // Real64 refrigerantSuperHeatedEnthalpy(EnergyPlusState, Refrigerant refrigerant, Real64 temperature, Real64 pressure) { // return reinterpret_cast(refrigerant)->superHeatedEnthalpy(temperature, pressure); diff --git a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc index 19baffc169c..f7ae5b15711 100644 --- a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc +++ b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc @@ -137,12 +137,12 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) state->dataPlnt->PlantFirstSizesOkayToFinalize = true; // calculate nominal capacity at 60.0 C hot water temperature - Real64 rho = FluidProperties::GetDensityGlycol(*state, + Real64 rho = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidIndex, "Boiler_HotWaterAutoSizeTempTest"); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc b/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc index 7bd0003246a..e32037d8699 100644 --- a/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc +++ b/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc @@ -2022,13 +2022,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) state->dataPlnt->PlantFinalSizesOkayToReport = true; // Calculate expected values - Real64 rho_cw = FluidProperties::GetDensityGlycol(*state, + Real64 rho_cw = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(chwLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(chwLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 Cp_evap = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 Cp_evap = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(chwLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(chwLoopNum).FluidIndex, @@ -2042,13 +2042,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) Real64 const SteamInputRatNom = thisChiller.SteamLoadCoef[0] + thisChiller.SteamLoadCoef[1] + thisChiller.SteamLoadCoef[2]; EXPECT_DOUBLE_EQ(1.0, SteamInputRatNom); - Real64 rho_cond = FluidProperties::GetDensityGlycol(*state, + Real64 rho_cond = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(cndLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(cndLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 Cp_cond = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 Cp_cond = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(cndLoopNum).FluidName, thisChiller.TempDesCondIn, state->dataPlnt->PlantLoop(cndLoopNum).FluidIndex, @@ -2058,13 +2058,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) expectedNomCap * (1.0 + SteamInputRatNom + nomCapToPumpRatio) / (rho_cond * Cp_cond * state->dataSize->PlantSizData(cndLoopNum).DeltaT); Real64 const SteamDeltaT = state->dataSize->PlantSizData(genLoopNum).DeltaT; - Real64 const Cp_gen = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 const Cp_gen = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(genLoopNum).FluidName, state->dataSize->PlantSizData(genLoopNum).ExitTemp, state->dataPlnt->PlantLoop(genLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 const rho_gen = FluidProperties::GetDensityGlycol(*state, + Real64 const rho_gen = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(genLoopNum).FluidName, (state->dataSize->PlantSizData(genLoopNum).ExitTemp - SteamDeltaT), state->dataPlnt->PlantLoop(genLoopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc index 1aaeb633ec5..d06b22313a7 100644 --- a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc +++ b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc @@ -685,7 +685,7 @@ TEST_F(EnergyPlusFixture, ExhAbsorption_calcHeater_Fix_Test) bool const runflaginput = true; thisChillerHeater.calcHeater(*state, loadinput, runflaginput); - const Real64 CpHW = FluidProperties::GetSpecificHeatGlycol(*state, hwPlantLoop.FluidName, hwReturnTemp, hwPlantLoop.FluidIndex, "UnitTest"); + const Real64 CpHW = Fluid::GetSpecificHeatGlycol(*state, hwPlantLoop.FluidName, hwReturnTemp, hwPlantLoop.FluidIndex, "UnitTest"); EXPECT_EQ(4185.0, CpHW); const Real64 expectedHeatingLoad = (hwSupplySetpoint - hwReturnTemp) * hwMassFlow * CpHW; diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc index 43e61139917..5e229225aaa 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc @@ -118,7 +118,7 @@ void EnergyPlusFixture::SetUp() state->dataUtilityRoutines->outputErrorHeader = false; Psychrometrics::InitializePsychRoutines(*state); - FluidProperties::InitializeGlycRoutines(); + Fluid::InitializeGlycRoutines(); createCoilSelectionReportObj(*state); } @@ -349,8 +349,8 @@ bool EnergyPlusFixture::process_idf(std::string_view const idf_snippet, bool use inputProcessor->initializeMaps(); SimulationManager::PostIPProcessing(*state); - FluidProperties::GetFluidPropertiesData(*state); - state->dataFluidProps->GetInput = false; + Fluid::GetFluidPropertiesData(*state); + state->dataFluid->GetInput = false; if (state->dataSQLiteProcedures->sqlite) { bool writeOutputToSQLite = false; diff --git a/tst/EnergyPlus/unit/FluidProperties.unit.cc b/tst/EnergyPlus/unit/FluidProperties.unit.cc index 86ad3a2978f..d6539ee8ed8 100644 --- a/tst/EnergyPlus/unit/FluidProperties.unit.cc +++ b/tst/EnergyPlus/unit/FluidProperties.unit.cc @@ -59,7 +59,6 @@ #include "Fixtures/EnergyPlusFixture.hh" using namespace EnergyPlus; -using namespace EnergyPlus::FluidProperties; TEST_F(EnergyPlusFixture, FluidProperties_GetDensityGlycol) { @@ -76,17 +75,17 @@ TEST_F(EnergyPlusFixture, FluidProperties_GetDensityGlycol) int FluidIndex = 0; - EXPECT_NEAR(1037.89, GetDensityGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1037.89, GetDensityGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1034.46, GetDensityGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1030.51, GetDensityGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1026.06, GetDensityGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1021.09, GetDensityGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1015.62, GetDensityGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1003.13, GetDensityGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(988.60, GetDensityGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(972.03, GetDensityGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(953.41, GetDensityGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1037.89, Fluid::GetDensityGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1037.89, Fluid::GetDensityGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1034.46, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1030.51, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1026.06, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1021.09, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1015.62, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1003.13, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(988.60, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(972.03, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(953.41, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); } TEST_F(EnergyPlusFixture, FluidProperties_GetSpecificHeatGlycol) @@ -104,17 +103,17 @@ TEST_F(EnergyPlusFixture, FluidProperties_GetSpecificHeatGlycol) int FluidIndex = 0; - EXPECT_NEAR(3779, GetSpecificHeatGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3779, GetSpecificHeatGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3807, GetSpecificHeatGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3834, GetSpecificHeatGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3862, GetSpecificHeatGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3889, GetSpecificHeatGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3917, GetSpecificHeatGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3972, GetSpecificHeatGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4027, GetSpecificHeatGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4082, GetSpecificHeatGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4137, GetSpecificHeatGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3779, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3779, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3807, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3834, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3862, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3889, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3917, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3972, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4027, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4082, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4137, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); } TEST_F(EnergyPlusFixture, FluidProperties_InterpValuesForGlycolConc) @@ -142,7 +141,7 @@ TEST_F(EnergyPlusFixture, FluidProperties_InterpValuesForGlycolConc) Result.allocate(NumTemp); // Test interpolation for the single-concentration scenario - InterpValuesForGlycolConc(*state, + Fluid::InterpValuesForGlycolConc(*state, NumCon, // number of concentrations (dimension of raw data) NumTemp, // number of temperatures (dimension of raw data) ConData, // concentrations for raw data diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index e672738732c..8b73ce09b9c 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -103,7 +103,6 @@ using namespace EnergyPlus::DataPlant; using namespace EnergyPlus::DataSizing; using namespace EnergyPlus::DataZoneEquipment; using namespace EnergyPlus::DataZoneEnergyDemands; -using namespace EnergyPlus::FluidProperties; using namespace EnergyPlus::DXCoils; using namespace EnergyPlus::Fans; using namespace EnergyPlus::HeatBalanceManager; @@ -2355,7 +2354,7 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) // Read in IDF ProcessScheduleInput(*state); // read schedules Curve::GetCurveInput(*state); // read curves - FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties + Fluid::GetFluidPropertiesData(*state); // read refrigerant properties // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; @@ -2396,7 +2395,7 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) state->dataEnvrn->OutDryBulbTemp = 10.35; // Run - Temperature = GetSupHeatTempRefrig(*state, Refrigerant, Pressure, Enthalpy, TempLow, TempUp, RefrigIndex, CalledFrom); + Temperature = Fluid::GetSupHeatTempRefrig(*state, Refrigerant, Pressure, Enthalpy, TempLow, TempUp, RefrigIndex, CalledFrom); // Test EXPECT_NEAR(Temperature, 44.5, 0.5); @@ -5860,12 +5859,12 @@ TEST_F(EnergyPlusFixture, VRFTest_SysCurve_WaterCooled) EXPECT_TRUE(state->dataHVACVarRefFlow->VRF(VRFCond).VRFCondPLR > 0.0); EXPECT_NEAR(SysOutputProvided, state->dataZoneEnergyDemand->ZoneSysEnergyDemand(CurZoneNum).RemainingOutputReqToCoolSP, 1.0); - rho = GetDensityGlycol(*state, + rho = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, state->dataSize->PlantSizData(1).ExitTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = GetSpecificHeatGlycol(*state, + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, state->dataSize->PlantSizData(1).ExitTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, @@ -5875,7 +5874,7 @@ TEST_F(EnergyPlusFixture, VRFTest_SysCurve_WaterCooled) EXPECT_DOUBLE_EQ(CondVolFlowRate, state->dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate); - rho = GetDensityGlycol(*state, + rho = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, @@ -22716,7 +22715,7 @@ TEST_F(EnergyPlusFixture, VRF_MixedTypes) // Read in IDF ProcessScheduleInput(*state); // read schedules Curve::GetCurveInput(*state); // read curves - FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties + Fluid::GetFluidPropertiesData(*state); // read refrigerant properties // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; diff --git a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc index 1d92e5a3a85..741e539eb56 100644 --- a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc +++ b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc @@ -72,7 +72,6 @@ using namespace ScheduleManager; using namespace Psychrometrics; using namespace HWBaseboardRadiator; using namespace DataLoopNode; -using namespace FluidProperties; using namespace DataPlant; TEST_F(EnergyPlusFixture, HWBaseboardRadiator_CalcHWBaseboard) diff --git a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc index fd592fbe9ab..abf6b69f0a3 100644 --- a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc +++ b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc @@ -82,7 +82,6 @@ using namespace EnergyPlus::DataHeatBalance; using namespace EnergyPlus::DataPlant; using namespace EnergyPlus::DataZoneEquipment; using namespace EnergyPlus::DataSizing; -using namespace EnergyPlus::FluidProperties; using namespace EnergyPlus::DataPlant; using namespace EnergyPlus::DataSurfaces; @@ -1201,24 +1200,24 @@ TEST_F(LowTempRadiantSystemTest, AutosizeLowTempRadiantVariableFlowTest) CoolingCapacity = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad * state->dataLowTempRadSys->HydrRadSys(RadSysNum).ScaledCoolingCapacity; // hot water flow rate sizing calculation - Density = GetDensityGlycol(*state, + Density = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = GetSpecificHeatGlycol(*state, + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); HotWaterFlowRate = HeatingCapacity / (state->dataSize->PlantSizData(1).DeltaT * Cp * Density); // chilled water flow rate sizing calculation - Density = GetDensityGlycol(*state, + Density = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = GetSpecificHeatGlycol(*state, + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, @@ -2631,12 +2630,12 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad = 1000.0; // hot water volume flow rate sizing calculation - Density = GetDensityGlycol(*state, + Density = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = GetSpecificHeatGlycol(*state, + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, @@ -2656,12 +2655,12 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax = AutoSize; // chilled water volume flow rate sizing calculation - Density = GetDensityGlycol(*state, + Density = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = GetSpecificHeatGlycol(*state, + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc index fe22f162eb7..8ba54110eea 100644 --- a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc +++ b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc @@ -94,7 +94,6 @@ using namespace EnergyPlus::Psychrometrics; using namespace EnergyPlus::ScheduleManager; using namespace EnergyPlus::SteamCoils; using namespace EnergyPlus::WaterCoils; -using namespace EnergyPlus::FluidProperties; namespace EnergyPlus { @@ -688,10 +687,10 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) Real64 DesWaterCoolingCoilLoad = DesAirMassFlow * (EnthalpyAirIn - EnthalpyAirOut) + FanCoolLoad; Real64 CoilDesWaterDeltaT = state->dataSize->PlantSizData(1).DeltaT; - Real64 Cp = GetSpecificHeatGlycol( + Real64 Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); Real64 rho = - GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); + Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); Real64 DesCoolingCoilWaterVolFlowRate = DesWaterCoolingCoilLoad / (CoilDesWaterDeltaT * Cp * rho); // check water coil water flow rate calc EXPECT_EQ(DesWaterCoolingCoilLoad, state->dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate); @@ -994,11 +993,11 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_SteamHeatingCoilAutoSizeTest) Real64 DesSteamCoilLoad = DesAirMassFlow * CpAirAvg * (DesCoilOutTemp - DesCoilInTemp); // do steam flow rate sizing calculation - Real64 EnthSteamIn = GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 EnthSteamOut = GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 SteamDensity = GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamIn = Fluid::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamOut = Fluid::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 SteamDensity = Fluid::GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); Real64 CpOfCondensate = - GetSatSpecificHeatRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Fluid::GetSatSpecificHeatRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); Real64 LatentHeatChange = EnthSteamIn - EnthSteamOut; Real64 DesMaxSteamVolFlowRate = DesSteamCoilLoad / (SteamDensity * (LatentHeatChange + state->dataSteamCoils->SteamCoil(1).DegOfSubcooling * CpOfCondensate)); diff --git a/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc b/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc index 8eda2e0503b..f96cb4c1ffe 100644 --- a/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc +++ b/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc @@ -139,7 +139,7 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictHeatingWater.BeginEnvrnInitFlag = true; thisDistrictHeatingWater.simulate(*state, locHotWater, firstHVAC, MyLoad, RunFlag); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 Cp = Fluid::GetSpecificHeatGlycol( *state, thisHotWaterLoop.FluidName, thisDistrictHeatingWater.InletTemp, thisHotWaterLoop.FluidIndex, RoutineName); Real64 calOutletTemp = (MyLoad + thisHotWaterLoop.MaxMassFlowRate * Cp * thisDistrictHeatingWater.InletTemp) / (thisHotWaterLoop.MaxMassFlowRate * Cp); @@ -173,7 +173,7 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictCooling.BeginEnvrnInitFlag = true; thisDistrictCooling.simulate(*state, locChilledWater, firstHVAC, MyLoad, RunFlag); - Cp = FluidProperties::GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, thisChilledWaterLoop.FluidName, thisDistrictCooling.InletTemp, thisChilledWaterLoop.FluidIndex, RoutineName); calOutletTemp = (MyLoad + thisChilledWaterLoop.MaxMassFlowRate * Cp * thisDistrictCooling.InletTemp) / (thisChilledWaterLoop.MaxMassFlowRate * Cp); @@ -204,14 +204,14 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictHeatingSteam.BeginEnvrnInitFlag = true; thisDistrictHeatingSteam.simulate(*state, locSteam, firstHVAC, MyLoad, RunFlag); - Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig( + Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig( *state, thisSteamLoop.FluidName, DataEnvironment::StdPressureSeaLevel, thisSteamLoop.FluidIndex, RoutineName); - Real64 CpCondensate = FluidProperties::GetSpecificHeatGlycol( + Real64 CpCondensate = Fluid::GetSpecificHeatGlycol( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, thisSteamLoop.FluidIndex, RoutineName); Real64 deltaTsensible = SatTempAtmPress - thisDistrictHeatingSteam.InletTemp; - Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, 1.0, thisSteamLoop.FluidIndex, RoutineName); - Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, 0.0, thisSteamLoop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; Real64 calOutletMdot = MyLoad / (LatentHeatSteam + (CpCondensate * deltaTsensible)); diff --git a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc index 913657fa1d0..454e54ad473 100644 --- a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc +++ b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc @@ -137,25 +137,25 @@ TEST_F(EnergyPlusFixture, ChillerHeater_Autosize) state->dataPlantCentralGSHP->Wrapper(1).GLHEPlantLoc.loopNum = PltSizCondNum; // Calculate expected values - Real64 rho_evap = FluidProperties::GetDensityGlycol(*state, + Real64 rho_evap = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(PltSizNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 Cp_evap = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 Cp_evap = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(PltSizNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 rho_cond = FluidProperties::GetDensityGlycol(*state, + Real64 rho_cond = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(PltSizCondNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizCondNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 Cp_cond = FluidProperties::GetSpecificHeatGlycol(*state, + Real64 Cp_cond = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(PltSizCondNum).FluidName, state->dataPlantCentralGSHP->Wrapper(1).ChillerHeater(1).TempRefCondInCooling, state->dataPlnt->PlantLoop(PltSizCondNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc index 67142450ce6..7996d5a5179 100644 --- a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc +++ b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc @@ -178,8 +178,8 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Waterloop) std::string_view RoutineName("PlantLoadProfileTests"); thisLoadProfileWaterLoop.simulate(*state, locWater, firstHVAC, curLoad, runFlag); - Real64 rhoWater = FluidProperties::GetDensityGlycol(*state, thisWaterLoop.FluidName, 60, thisWaterLoop.FluidIndex, RoutineName); - Real64 Cp = FluidProperties::GetSpecificHeatGlycol( + Real64 rhoWater = Fluid::GetDensityGlycol(*state, thisWaterLoop.FluidName, 60, thisWaterLoop.FluidIndex, RoutineName); + Real64 Cp = Fluid::GetSpecificHeatGlycol( *state, thisWaterLoop.FluidName, thisLoadProfileWaterLoop.InletTemp, thisWaterLoop.FluidIndex, RoutineName); Real64 deltaTemp = curLoad / (rhoWater * thisLoadProfileWaterLoop.VolFlowRate * Cp); Real64 calOutletTemp = thisLoadProfileWaterLoop.InletTemp - deltaTemp; @@ -209,7 +209,7 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Steamloop) std::string_view RoutineName("PlantLoadProfileTests"); - Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig( + Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig( *state, state->dataPlnt->PlantLoop(1).FluidName, DataEnvironment::StdPressureSeaLevel, state->dataPlnt->PlantLoop(1).FluidIndex, RoutineName); state->dataLoopNodes->Node(1).Temp = SatTempAtmPress; @@ -252,12 +252,12 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Steamloop) thisLoadProfileSteamLoop.simulate(*state, locSteam, firstHVAC, curLoad, runFlag); Real64 EnthSteamIn = - FluidProperties::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 1.0, thisSteamLoop.FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 1.0, thisSteamLoop.FluidIndex, RoutineName); Real64 EnthSteamOut = - FluidProperties::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 0.0, thisSteamLoop.FluidIndex, RoutineName); + Fluid::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 0.0, thisSteamLoop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamIn - EnthSteamOut; Real64 CpCondensate = - FluidProperties::GetSpecificHeatGlycol(*state, thisSteamLoop.FluidName, SatTempAtmPress, thisSteamLoop.FluidIndex, RoutineName); + Fluid::GetSpecificHeatGlycol(*state, thisSteamLoop.FluidName, SatTempAtmPress, thisSteamLoop.FluidIndex, RoutineName); Real64 calOutletMdot = curLoad / (LatentHeatSteam + thisLoadProfileSteamLoop.DegOfSubcooling * CpCondensate); EXPECT_EQ(thisLoadProfileSteamLoop.MassFlowRate, calOutletMdot); diff --git a/tst/EnergyPlus/unit/SetPointManager.unit.cc b/tst/EnergyPlus/unit/SetPointManager.unit.cc index 0ba7a3af76f..1a2f04c9997 100644 --- a/tst/EnergyPlus/unit/SetPointManager.unit.cc +++ b/tst/EnergyPlus/unit/SetPointManager.unit.cc @@ -189,8 +189,8 @@ TEST_F(EnergyPlusFixture, SetPointManager_DefineReturnWaterChWSetPointManager_Fl ASSERT_TRUE(process_idf(idf_objects)); - EXPECT_EQ(2, state->dataFluidProps->NumOfGlycols); - const auto &thisGlycol = state->dataFluidProps->GlycolData(2); + EXPECT_EQ(2, state->dataFluid->NumOfGlycols); + const auto &thisGlycol = state->dataFluid->GlycolData(2); EXPECT_EQ("ETHYLENEGLYCOL40PERCENT", thisGlycol.Name); EXPECT_EQ("ETHYLENEGLYCOL", thisGlycol.GlycolName); diff --git a/tst/EnergyPlus/unit/UnitHeater.unit.cc b/tst/EnergyPlus/unit/UnitHeater.unit.cc index ae8f65690d5..3d53f4424c6 100644 --- a/tst/EnergyPlus/unit/UnitHeater.unit.cc +++ b/tst/EnergyPlus/unit/UnitHeater.unit.cc @@ -89,7 +89,6 @@ using namespace EnergyPlus::DataSurfaces; using namespace EnergyPlus::DataZoneEquipment; using namespace EnergyPlus::DataZoneEnergyDemands; using namespace EnergyPlus::Fans; -using namespace EnergyPlus::FluidProperties; using namespace EnergyPlus::HeatBalanceManager; using namespace EnergyPlus::OutputProcessor; using namespace EnergyPlus::OutputReportPredefined; @@ -1152,12 +1151,12 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest) EXPECT_FALSE(ErrorsFound); HWMaxVolFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; - HWDensity = GetDensityGlycol(*state, + HWDensity = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, "xxx"); - CpHW = GetSpecificHeatGlycol(*state, + CpHW = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, @@ -1399,7 +1398,7 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) EXPECT_NEAR(UHHeatingRate, state->dataUnitHeaters->UnitHeat(UnitHeatNum).HeatPower, ConvTol); // verify the heat rate delivered by the hot water heating coil HWMassFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; - CpHW = GetSpecificHeatGlycol(*state, + CpHW = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 427ab85de53..41ce3190923 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -382,7 +382,7 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = state->dataWaterCoils->WaterCoil(CoilNum).Name; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; createCoilSelectionReportObj(*state); WaterCoils::SizeWaterCoil(*state, CoilNum); diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 7faecd4d5ec..0d0fdbd31be 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -102,7 +102,6 @@ using namespace EnergyPlus::DataZoneEnergyDemands; using namespace EnergyPlus::DataZoneEquipment; using namespace EnergyPlus::FanCoilUnits; using namespace EnergyPlus::Fans; -using namespace EnergyPlus::FluidProperties; using namespace EnergyPlus::General; using namespace EnergyPlus::GlobalNames; using namespace EnergyPlus::HeatBalanceManager; @@ -229,7 +228,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; createCoilSelectionReportObj(*state); SizeWaterCoil(*state, CoilNum); @@ -464,7 +463,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -492,9 +491,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -620,7 +619,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -648,9 +647,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -780,7 +779,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -808,9 +807,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -900,7 +899,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -922,9 +921,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (state->dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp * Cp * rho); @@ -1018,7 +1017,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1039,9 +1038,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); // check cooling coil design water flow rate @@ -1143,7 +1142,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; OutputReportPredefined::SetPredefinedTables(*state); @@ -1166,9 +1165,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); // check cooling coil design water flow rate @@ -1299,7 +1298,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 10.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1321,9 +1320,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = GetSpecificHeatGlycol( + Cp = Fluid::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol( + rho = Fluid::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (11.0 * Cp * rho); @@ -1395,7 +1394,7 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; + state->dataFluid->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -1423,8 +1422,8 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) Real64 DesWaterFlowRate(0.0); // now size heating coil hot water flow rate at 60.0C - Cp = GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + rho = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = DesCoilHeatingLoad / (state->dataSize->PlantSizData(1).DeltaT * Cp * rho); // check heating coil design water flow rate calculated here and sizing results are identical diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc index ff99c1ca594..ae221acb93a 100644 --- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc +++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc @@ -543,9 +543,6 @@ TEST_F(EnergyPlusFixture, HPWHWrappedDummyNodeConfig) TEST_F(EnergyPlusFixture, HPWHEnergyBalance) { - using FluidProperties::GetSpecificHeatGlycol; - using FluidProperties::Water; - std::string idf_objects = delimited_string({ "Schedule:Constant,", " WaterHeaterSP1Schedule, !- Name", @@ -774,7 +771,7 @@ TEST_F(EnergyPlusFixture, HPWHEnergyBalance) state->dataWaterThermalTanks->mdotAir = 0.0993699992873531; int GlycolIndex = 0; - const Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, Water, Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); + const Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, Fluid::Water, Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); Tank.CalcHeatPumpWaterHeater(*state, false); @@ -2019,7 +2016,7 @@ TEST_F(EnergyPlusFixture, StratifiedTankCalc) auto &node = Tank.Node[i]; TankNodeEnergy += node.Mass * (NodeTemps[i] - PrevNodeTemps[i]); } - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); + Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); TankNodeEnergy *= Cp; EXPECT_NEAR(Tank.NetHeatTransferRate * state->dataHVACGlobal->TimeStepSysSec, TankNodeEnergy, fabs(TankNodeEnergy * 0.0001)); @@ -2158,7 +2155,7 @@ TEST_F(EnergyPlusFixture, StratifiedTankSourceFlowRateCalc) Tank.SourceMassFlowRate = 6.30901964e-5 * 997; // 1 gal/min int DummyIndex = 1; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); + Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); Tank.CalcWaterThermalTankStratified(*state); @@ -3135,7 +3132,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_Multispeed_Coil_Test) TEST_F(EnergyPlusFixture, MixedTankAlternateSchedule) { - using FluidProperties::GetDensityGlycol; + using Fluid::GetDensityGlycol; std::string const idf_objects = delimited_string({ "Schedule:Constant, Inlet Water Temperature, , 10.0;", @@ -3223,7 +3220,7 @@ TEST_F(EnergyPlusFixture, MixedTankAlternateSchedule) // Source side is in the demand side of the plant loop Tank.SrcSidePlantLoc.loopSideNum = EnergyPlus::DataPlant::LoopSideLocation::Demand; Tank.SavedSourceOutletTemp = 60.0; - rho = GetDensityGlycol(*state, "Water", Tank.TankTemp, WaterIndex, "MixedTankAlternateSchedule"); + rho = Fluid::GetDensityGlycol(*state, "Water", Tank.TankTemp, WaterIndex, "MixedTankAlternateSchedule"); // Set the available max flow rates for tank and node Tank.PlantSourceMassFlowRateMax = Tank.SourceDesignVolFlowRate * rho; diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc index a54a3d35aec..7a3b1236092 100644 --- a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc @@ -137,61 +137,61 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) ASSERT_TRUE(process_idf(idf_objects)); - state->dataFluidProps->RefrigData.allocate(1); - state->dataFluidProps->RefrigData(1).Name = "R22"; - state->dataFluidProps->RefrigData(1).PsLowTempIndex = 1; - state->dataFluidProps->RefrigData(1).PsHighTempIndex = 2; - state->dataFluidProps->RefrigData(1).PsTemps.allocate(2); - state->dataFluidProps->RefrigData(1).PsTemps(1) = -157.42; - state->dataFluidProps->RefrigData(1).PsTemps(2) = 96.145; - state->dataFluidProps->RefrigData(1).PsValues.allocate(2); - state->dataFluidProps->RefrigData(1).PsValues(1) = 0.3795; - state->dataFluidProps->RefrigData(1).PsValues(2) = 4990000.0; - - state->dataFluidProps->RefrigData(1).HfLowTempIndex = 1; - state->dataFluidProps->RefrigData(1).HfHighTempIndex = 2; - state->dataFluidProps->RefrigData(1).PsLowPresIndex = 1; - state->dataFluidProps->RefrigData(1).PsHighPresIndex = 2; - state->dataFluidProps->RefrigData(1).HTemps.allocate(2); - state->dataFluidProps->RefrigData(1).HfValues.allocate(2); - state->dataFluidProps->RefrigData(1).HfgValues.allocate(2); - - state->dataFluidProps->RefrigData(1).HTemps(1) = -157.42; - state->dataFluidProps->RefrigData(1).HTemps(2) = 96.145; - state->dataFluidProps->RefrigData(1).HfValues(1) = 29600.0; - state->dataFluidProps->RefrigData(1).HfValues(2) = 366900.0; - state->dataFluidProps->RefrigData(1).HfgValues(1) = 332700.0; - state->dataFluidProps->RefrigData(1).HfgValues(2) = 366900.0; - state->dataFluidProps->RefrigData(1).NumSuperTempPts = 2; - state->dataFluidProps->RefrigData(1).NumSuperPressPts = 2; - state->dataFluidProps->RefrigData(1).SHTemps.allocate(2); - state->dataFluidProps->RefrigData(1).SHPress.allocate(2); - state->dataFluidProps->RefrigData(1).SHTemps(1) = -157.15; - state->dataFluidProps->RefrigData(1).SHTemps(2) = 152.85; - state->dataFluidProps->RefrigData(1).SHPress(1) = 0.4043; - state->dataFluidProps->RefrigData(1).SHPress(2) = 16500000.0; - state->dataFluidProps->RefrigData(1).HshValues.allocate(2, 2); - state->dataFluidProps->RefrigData(1).HshValues(1, 1) = 332800.0; - state->dataFluidProps->RefrigData(1).HshValues(1, 2) = 537000.0; - state->dataFluidProps->RefrigData(1).HshValues(2, 1) = 332800.0; - state->dataFluidProps->RefrigData(1).HshValues(2, 2) = 537000.0; - state->dataFluidProps->RefrigData(1).RhoshValues.allocate(2, 2); - state->dataFluidProps->RefrigData(1).RhoshValues(1, 1) = 0.00003625; - state->dataFluidProps->RefrigData(1).RhoshValues(1, 2) = 0.0; - state->dataFluidProps->RefrigData(1).RhoshValues(2, 1) = 0.00003625; - state->dataFluidProps->RefrigData(1).RhoshValues(2, 2) = 0.0; - - state->dataFluidProps->RefrigData(1).RhofLowTempIndex = 1; - state->dataFluidProps->RefrigData(1).RhofHighTempIndex = 2; - state->dataFluidProps->RefrigData(1).RhoTemps.allocate(2); - state->dataFluidProps->RefrigData(1).RhoTemps(1) = -157.42; - state->dataFluidProps->RefrigData(1).RhoTemps(2) = 96.145; - state->dataFluidProps->RefrigData(1).RhofValues.allocate(2); - state->dataFluidProps->RefrigData(1).RhofValues(1) = 1721.0; - state->dataFluidProps->RefrigData(1).RhofValues(2) = 523.8; - state->dataFluidProps->RefrigData(1).RhofgValues.allocate(2); - state->dataFluidProps->RefrigData(1).RhofgValues(1) = 0.341; - state->dataFluidProps->RefrigData(1).RhofgValues(2) = 523.8; + state->dataFluid->RefrigData.allocate(1); + state->dataFluid->RefrigData(1).Name = "R22"; + state->dataFluid->RefrigData(1).PsLowTempIndex = 1; + state->dataFluid->RefrigData(1).PsHighTempIndex = 2; + state->dataFluid->RefrigData(1).PsTemps.allocate(2); + state->dataFluid->RefrigData(1).PsTemps(1) = -157.42; + state->dataFluid->RefrigData(1).PsTemps(2) = 96.145; + state->dataFluid->RefrigData(1).PsValues.allocate(2); + state->dataFluid->RefrigData(1).PsValues(1) = 0.3795; + state->dataFluid->RefrigData(1).PsValues(2) = 4990000.0; + + state->dataFluid->RefrigData(1).HfLowTempIndex = 1; + state->dataFluid->RefrigData(1).HfHighTempIndex = 2; + state->dataFluid->RefrigData(1).PsLowPresIndex = 1; + state->dataFluid->RefrigData(1).PsHighPresIndex = 2; + state->dataFluid->RefrigData(1).HTemps.allocate(2); + state->dataFluid->RefrigData(1).HfValues.allocate(2); + state->dataFluid->RefrigData(1).HfgValues.allocate(2); + + state->dataFluid->RefrigData(1).HTemps(1) = -157.42; + state->dataFluid->RefrigData(1).HTemps(2) = 96.145; + state->dataFluid->RefrigData(1).HfValues(1) = 29600.0; + state->dataFluid->RefrigData(1).HfValues(2) = 366900.0; + state->dataFluid->RefrigData(1).HfgValues(1) = 332700.0; + state->dataFluid->RefrigData(1).HfgValues(2) = 366900.0; + state->dataFluid->RefrigData(1).NumSuperTempPts = 2; + state->dataFluid->RefrigData(1).NumSuperPressPts = 2; + state->dataFluid->RefrigData(1).SHTemps.allocate(2); + state->dataFluid->RefrigData(1).SHPress.allocate(2); + state->dataFluid->RefrigData(1).SHTemps(1) = -157.15; + state->dataFluid->RefrigData(1).SHTemps(2) = 152.85; + state->dataFluid->RefrigData(1).SHPress(1) = 0.4043; + state->dataFluid->RefrigData(1).SHPress(2) = 16500000.0; + state->dataFluid->RefrigData(1).HshValues.allocate(2, 2); + state->dataFluid->RefrigData(1).HshValues(1, 1) = 332800.0; + state->dataFluid->RefrigData(1).HshValues(1, 2) = 537000.0; + state->dataFluid->RefrigData(1).HshValues(2, 1) = 332800.0; + state->dataFluid->RefrigData(1).HshValues(2, 2) = 537000.0; + state->dataFluid->RefrigData(1).RhoshValues.allocate(2, 2); + state->dataFluid->RefrigData(1).RhoshValues(1, 1) = 0.00003625; + state->dataFluid->RefrigData(1).RhoshValues(1, 2) = 0.0; + state->dataFluid->RefrigData(1).RhoshValues(2, 1) = 0.00003625; + state->dataFluid->RefrigData(1).RhoshValues(2, 2) = 0.0; + + state->dataFluid->RefrigData(1).RhofLowTempIndex = 1; + state->dataFluid->RefrigData(1).RhofHighTempIndex = 2; + state->dataFluid->RefrigData(1).RhoTemps.allocate(2); + state->dataFluid->RefrigData(1).RhoTemps(1) = -157.42; + state->dataFluid->RefrigData(1).RhoTemps(2) = 96.145; + state->dataFluid->RefrigData(1).RhofValues.allocate(2); + state->dataFluid->RefrigData(1).RhofValues(1) = 1721.0; + state->dataFluid->RefrigData(1).RhofValues(2) = 523.8; + state->dataFluid->RefrigData(1).RhofgValues.allocate(2); + state->dataFluid->RefrigData(1).RhofgValues(1) = 0.341; + state->dataFluid->RefrigData(1).RhofgValues(2) = 523.8; GetWatertoAirHPInput(*state); @@ -306,5 +306,5 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) // clean up state->dataWaterToAirHeatPump->WatertoAirHP.deallocate(); - state->dataFluidProps->RefrigData.deallocate(); + state->dataFluid->RefrigData.deallocate(); } From 2aa9498bf156b1d67354cd041b7fee53d6ba6a1e Mon Sep 17 00:00:00 2001 From: rraustad Date: Thu, 27 Jun 2024 10:03:10 -0400 Subject: [PATCH 072/115] Move getInputs to init_state and update unit tests --- src/EnergyPlus/Data/EnergyPlusData.cc | 10 +- src/EnergyPlus/Data/EnergyPlusData.hh | 1 + src/EnergyPlus/FluidProperties.cc | 127 ++---------------- src/EnergyPlus/FluidProperties.hh | 7 +- src/EnergyPlus/HVACVariableRefrigerantFlow.cc | 8 -- src/EnergyPlus/Psychrometrics.hh | 3 +- src/EnergyPlus/SimulationManager.cc | 2 - src/EnergyPlus/SimulationManager.hh | 3 +- tst/EnergyPlus/unit/AirLoopHVACDOAS.unit.cc | 1 + .../unit/AirTerminalSingleDuct.unit.cc | 5 + .../unit/AirTerminalSingleDuctMixer.unit.cc | 1 - ...CoolingWaterDesAirOutletTempSizing.unit.cc | 2 + .../Autosizing/CoolingWaterflowSizing.unit.cc | 2 + ...ingWaterDesCoilLoadUsedForUASizing.unit.cc | 2 + .../Autosizing/HeatingWaterflowSizing.unit.cc | 2 + .../WaterHeatingCapacitySizing.unit.cc | 2 + .../WaterHeatingCoilUASizing.unit.cc | 2 + tst/EnergyPlus/unit/BoilerHotWater.unit.cc | 2 + .../unit/ChillerElectricEIR.unit.cc | 9 +- .../unit/DOASEffectOnZoneSizing.unit.cc | 2 +- tst/EnergyPlus/unit/DXCoils.unit.cc | 2 +- .../unit/EvaporativeFluidCoolers.unit.cc | 1 + tst/EnergyPlus/unit/FaultsManager.unit.cc | 4 +- .../unit/Fixtures/EnergyPlusFixture.cc | 16 ++- .../unit/Fixtures/EnergyPlusFixture.hh | 7 + tst/EnergyPlus/unit/Furnaces.unit.cc | 1 + .../unit/GroundHeatExchangers.unit.cc | 1 + .../unit/HVACInterfaceManager.unit.cc | 1 + .../unit/HVACMultiSpeedHeatPump.unit.cc | 2 +- .../unit/HVACSizingSimulationManager.unit.cc | 11 ++ .../unit/HVACVariableRefrigerantFlow.unit.cc | 3 +- .../unit/HWBaseboardRadiator.unit.cc | 1 + tst/EnergyPlus/unit/Humidifiers.unit.cc | 3 + tst/EnergyPlus/unit/InputProcessor.unit.cc | 39 +++++- .../unit/LowTempRadiantSystem.unit.cc | 5 + tst/EnergyPlus/unit/MixedAir.unit.cc | 3 +- tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc | 3 + tst/EnergyPlus/unit/OutputFiles.unit.cc | 1 - tst/EnergyPlus/unit/OutputProcessor.unit.cc | 3 + tst/EnergyPlus/unit/Pipes.unit.cc | 2 +- tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc | 1 + tst/EnergyPlus/unit/PlantChillers.unit.cc | 2 + tst/EnergyPlus/unit/PlantLoadProfile.unit.cc | 2 + tst/EnergyPlus/unit/PlantManager.unit.cc | 1 + tst/EnergyPlus/unit/PlantUtilities.unit.cc | 2 + .../unit/ReportCoilSelection.unit.cc | 2 + tst/EnergyPlus/unit/SimulationManager.unit.cc | 51 +++---- tst/EnergyPlus/unit/StandardRatings.unit.cc | 2 +- tst/EnergyPlus/unit/SurfaceGeometry.unit.cc | 1 + tst/EnergyPlus/unit/SwimmingPool.unit.cc | 1 + tst/EnergyPlus/unit/UnitarySystem.unit.cc | 5 + tst/EnergyPlus/unit/VAVDefMinMaxFlow.unit.cc | 10 ++ tst/EnergyPlus/unit/WaterCoils.unit.cc | 9 ++ tst/EnergyPlus/unit/WaterUse.unit.cc | 2 + tst/EnergyPlus/unit/WeatherManager.unit.cc | 4 +- 55 files changed, 198 insertions(+), 199 deletions(-) diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index 03b30e7bfbb..d3c301a69dc 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -309,6 +309,7 @@ EnergyPlusData::~EnergyPlusData() = default; void EnergyPlusData::clear_state() { this->ready = true; + this->init_state_called = false; this->dataAirLoop->clear_state(); this->dataAirLoopHVACDOAS->clear_state(); this->dataAirSystemsData->clear_state(); @@ -570,11 +571,14 @@ void EnergyPlusData::clear_state() void EnergyPlusData::init_state(EnergyPlusData &state) { + if (this->init_state_called) return; // The order in which we do this matters. We're going to try to // do this in "topological" order meaning the first to go are the // objects that do not reference any other objects, like fluids, // schedules, curves, etc. - this->dataFluidProps->init_state(state); + this->dataFluidProps->init_state(state); // GetFluidPropertiesData + this->dataSimulationManager->init_state(state); // GetProjectData + this->dataPsychrometrics->init_state(state); // InitializePsychRoutines this->dataAirLoop->init_state(state); this->dataAirLoopHVACDOAS->init_state(state); @@ -736,7 +740,6 @@ void EnergyPlusData::init_state(EnergyPlusData &state) this->dataPollution->init_state(state); this->dataPondGHE->init_state(state); this->dataPowerInductionUnits->init_state(state); - this->dataPsychrometrics->init_state(state); this->dataPsychCache->init_state(state); this->dataPumps->init_state(state); this->dataPurchasedAirMgr->init_state(state); @@ -758,7 +761,6 @@ void EnergyPlusData::init_state(EnergyPlusData &state) this->dataSetPointManager->init_state(state); this->dataShadowComb->init_state(state); this->dataSimAirServingZones->init_state(state); - this->dataSimulationManager->init_state(state); this->dataSingleDuct->init_state(state); this->dataSize->init_state(state); this->dataSizingManager->init_state(state); @@ -823,6 +825,8 @@ void EnergyPlusData::init_state(EnergyPlusData &state) this->dataZoneEquipmentManager->init_state(state); this->dataZonePlenum->init_state(state); this->dataZoneTempPredictorCorrector->init_state(state); + + this->init_state_called = true; } } // namespace EnergyPlus diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index b1b4f3eeb3d..ff30f15b8f1 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -577,6 +577,7 @@ struct EnergyPlusData : BaseGlobalStruct EnergyPlusData(EnergyPlusData &&) = delete; void init_state([[maybe_unused]] EnergyPlusData &state) override; + bool init_state_called = false; void clear_state() override; }; diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index c4353b32718..00d23bd4893 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -162,6 +162,9 @@ namespace FluidProperties { // Array initializer only takes one argument. std::bind is used to convert the // actual initializer into a function of one argument. + if (state.dataFluidProps->GetFluidPropertiesData_called) return; + state.dataFluidProps->GetFluidPropertiesData_called = true; + // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol static constexpr std::array DefaultGlycolTemps = { @@ -4926,8 +4929,6 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from glycol functions - state.dataFluidProps->GetInput = false; // input has already been gotten - for (int GlycolNum = 1; GlycolNum <= state.dataFluidProps->NumOfGlycols; ++GlycolNum) { auto &glycol = state.dataFluidProps->GlycolData(GlycolNum); int GlycolIndex = 0; // used in routine calls -- value is returned when first 0 @@ -5168,8 +5169,6 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from refrigerant functions - state.dataFluidProps->GetInput = false; // input has already been gotten - for (int RefrigNum = 1; RefrigNum <= state.dataFluidProps->NumOfRefrigerants; ++RefrigNum) { int RefrigIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: @@ -5606,23 +5605,15 @@ namespace FluidProperties { // FUNCTION LOCAL VARIABLE DECLARATIONS: int HiTempIndex; // index value of next highest Temperature from table int LoTempIndex; // index value of next lowest Temperature from table - int RefrigNum; // index for refrigerant under consideration Real64 TempInterpRatio; // ratio to interpolate in temperature domain - // error counters and dummy string - bool ErrorFlag; // error flag for current call - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - - RefrigNum = 0; + int RefrigNum = 0; // index for refrigerant under consideration if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); } - ErrorFlag = false; + bool ErrorFlag = false; if (RefrigIndex > 0) { RefrigNum = RefrigIndex; @@ -5717,23 +5708,15 @@ namespace FluidProperties { // FUNCTION LOCAL VARIABLE DECLARATIONS: int HiPresIndex; // index value of next highest Temperature from table int LoPresIndex; // index value of next lowest Temperature from table - int RefrigNum; // index for refrigerant under consideration Real64 PresInterpRatio; // ratio to interpolate in temperature domain - // error counters and dummy string - bool ErrorFlag; // error flag for current call - - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - RefrigNum = 0; + int RefrigNum = 0; // index for refrigerant under consideration if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); } - ErrorFlag = false; + bool ErrorFlag = false; if (RefrigIndex > 0) { RefrigNum = RefrigIndex; @@ -5832,14 +5815,7 @@ namespace FluidProperties { static constexpr std::string_view RoutineName("GetSatEnthalpyRefrig"); // FUNCTION LOCAL VARIABLE DECLARATIONS: - int RefrigNum; // index for refrigerant under consideration - - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - - RefrigNum = 0; + int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); @@ -5905,13 +5881,6 @@ namespace FluidProperties { Real64 HiSatProp; // Sat. prop. at higher temp & given quality Real64 TempInterpRatio; // ratio to interpolate in temperature domain - // error counters and dummy string - - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -6040,11 +6009,6 @@ namespace FluidProperties { // FUNCTION PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("GetSatSpecificHeatRefrig: "); - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -6146,12 +6110,6 @@ namespace FluidProperties { int HiTempIndex; // high temperature index value int HiPressIndex; // high pressure index value - // see if data is there - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -6398,11 +6356,6 @@ namespace FluidProperties { int LoEnthalpyIndex; // Index value of lower enthalpy from data int HiEnthalpyIndex; // Index value of higher enthalpy from data - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -6674,11 +6627,6 @@ namespace FluidProperties { Real64 RefTSat; // Saturated temperature of the refrigerant. Used to check whether the refrigernat is in the superheat area Real64 Temp; // Temperature of the superheated refrigerant at the given enthalpy and pressure - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -6822,12 +6770,6 @@ namespace FluidProperties { int HiTempIndex; // high temperature index value int HiPressIndex; // high pressure index value - // see if data is there - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - int RefrigNum = 0; if (state.dataFluidProps->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( @@ -7091,12 +7033,6 @@ namespace FluidProperties { // FUNCTION PARAMETERS: static constexpr std::string_view RoutineName("GetSpecificHeatGlycol: "); - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // If no glycols, no fluid properties can be evaluated int GlycolNum(0); if (state.dataFluidProps->NumOfGlycols == 0) @@ -7243,12 +7179,6 @@ namespace FluidProperties { bool LowErrorThisTime = false; bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; if (state.dataFluidProps->NumOfGlycols == 0) @@ -7406,12 +7336,6 @@ namespace FluidProperties { bool LowErrorThisTime = false; bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; if (state.dataFluidProps->NumOfGlycols == 0) @@ -7572,12 +7496,6 @@ namespace FluidProperties { bool LowErrorThisTime = false; bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; if (state.dataFluidProps->NumOfGlycols == 0) @@ -7727,12 +7645,6 @@ namespace FluidProperties { // Return value int FindRefrigerant; - // Make sure we have already read in the input - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // Check to see if this glycol shows up in the glycol data int Found = Util::FindItemInList(Util::makeUPPER(Refrigerant), state.dataFluidProps->RefrigData); @@ -7769,12 +7681,6 @@ namespace FluidProperties { // Return value int FindGlycol; - // Make sure we have already read in the input - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // Check to see if this glycol shows up in the glycol data int Found = Util::FindItemInList(Util::makeUPPER(Glycol), state.dataFluidProps->GlycolData, @@ -8024,11 +7930,6 @@ namespace FluidProperties { // Return value int CheckFluidPropertyName; - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - // Item must be either in Refrigerant or Glycol list int Found = 0; if (state.dataFluidProps->NumOfRefrigerants > 0) { @@ -8192,12 +8093,6 @@ namespace FluidProperties { void GetFluidDensityTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - if (FluidIndex > 0) { MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoLowTempValue; MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoHighTempValue; @@ -8206,12 +8101,6 @@ namespace FluidProperties { void GetFluidSpecificHeatTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { - // Get the input if we haven't already - if (state.dataFluidProps->GetInput) { - GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } - if (FluidIndex > 0) { MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpLowTempValue; MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpHighTempValue; diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index c0e77cc9006..9dc3180b2e7 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -627,9 +627,9 @@ namespace FluidProperties { struct FluidPropertiesData : BaseGlobalStruct { - bool GetInput = true; // Used to get the input once only - int NumOfRefrigerants = 0; // Total number of refrigerants input by user - int NumOfGlycols = 0; // Total number of glycols input by user + bool GetFluidPropertiesData_called = false; // Used to get the input once only + int NumOfRefrigerants = 0; // Total number of refrigerants input by user + int NumOfGlycols = 0; // Total number of glycols input by user bool DebugReportGlycols = false; bool DebugReportRefrigerants = false; int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called @@ -665,7 +665,6 @@ struct FluidPropertiesData : BaseGlobalStruct void init_state(EnergyPlusData &state) override { FluidProperties::GetFluidPropertiesData(state); - this->GetInput = false; } void clear_state() override diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index bce02535fa9..ea402f0ea39 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -2484,10 +2484,6 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) // Refrigerant type thisVrfFluidCtrl.RefrigerantName = cAlphaArgs(4); - if (state.dataFluidProps->GetInput) { - EnergyPlus::FluidProperties::GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } if (Util::FindItemInList(thisVrfFluidCtrl.RefrigerantName, state.dataFluidProps->RefrigData, state.dataFluidProps->NumOfRefrigerants) == 0) { ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrl.Name); ShowContinueError(state, "Illegal " + cAlphaFieldNames(4) + " = " + cAlphaArgs(4)); @@ -2883,10 +2879,6 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) // Refrigerant type thisVrfFluidCtrlHR.RefrigerantName = cAlphaArgs(4); - if (state.dataFluidProps->GetInput) { - EnergyPlus::FluidProperties::GetFluidPropertiesData(state); - state.dataFluidProps->GetInput = false; - } if (Util::FindItemInList(thisVrfFluidCtrlHR.RefrigerantName, state.dataFluidProps->RefrigData, state.dataFluidProps->NumOfRefrigerants) == 0) { ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrlHR.Name); diff --git a/src/EnergyPlus/Psychrometrics.hh b/src/EnergyPlus/Psychrometrics.hh index 61360dac72a..b3ebe4d2cb1 100644 --- a/src/EnergyPlus/Psychrometrics.hh +++ b/src/EnergyPlus/Psychrometrics.hh @@ -1702,8 +1702,9 @@ struct PsychrometricsData : BaseGlobalStruct bool ReportErrors = true; bool useInterpolationPsychTsatFnPb = false; - void init_state([[maybe_unused]] EnergyPlusData &state) override + void init_state(EnergyPlusData &state) override { + Psychrometrics::InitializePsychRoutines(state); } void clear_state() override diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc index d3a03f22aab..c6597b1cd30 100644 --- a/src/EnergyPlus/SimulationManager.cc +++ b/src/EnergyPlus/SimulationManager.cc @@ -213,8 +213,6 @@ namespace SimulationManager { state.init_state(state); - GetProjectData(state); - Psychrometrics::InitializePsychRoutines(state); CheckForMisMatchedEnvironmentSpecifications(state); CheckForRequestedReporting(state); OutputReportPredefined::SetPredefinedTables(state); diff --git a/src/EnergyPlus/SimulationManager.hh b/src/EnergyPlus/SimulationManager.hh index a376d7ae25a..503404e3fc0 100644 --- a/src/EnergyPlus/SimulationManager.hh +++ b/src/EnergyPlus/SimulationManager.hh @@ -99,8 +99,9 @@ struct SimulationManagerData : BaseGlobalStruct bool RunControlInInput = false; bool PreP_Fatal = false; bool WarningOut = true; - void init_state([[maybe_unused]] EnergyPlusData &state) override + void init_state(EnergyPlusData &state) override { + SimulationManager::GetProjectData(state); } void clear_state() override diff --git a/tst/EnergyPlus/unit/AirLoopHVACDOAS.unit.cc b/tst/EnergyPlus/unit/AirLoopHVACDOAS.unit.cc index ea221d656a2..a33c98e10b8 100644 --- a/tst/EnergyPlus/unit/AirLoopHVACDOAS.unit.cc +++ b/tst/EnergyPlus/unit/AirLoopHVACDOAS.unit.cc @@ -10392,6 +10392,7 @@ TEST_F(EnergyPlusFixture, AirLoopHVACDOAS_TestOACompConnectionError) }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); MixedAir::GetOutsideAirSysInputs(*state); state->dataMixedAir->GetOASysInputFlag = false; diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc index 9c74daed695..ea3efeb30bb 100644 --- a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc +++ b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc @@ -1008,6 +1008,7 @@ TEST_F(EnergyPlusFixture, SingleDuctVAVReheatAirTerminal_MinFlowTurnDownTest) }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); // clear idf errors // setup variables for VAV Reheat int SysNum = 1; int ZoneNum = 1; @@ -1217,6 +1218,7 @@ TEST_F(EnergyPlusFixture, SingleDuctVAVReheatVSFanAirTerminal_MinFlowTurnDownTes }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); // clear idf errors // setup variables for VAV Reheat VS Fan int SysNum = 1; int ZoneNum = 1; @@ -1393,6 +1395,7 @@ TEST_F(EnergyPlusFixture, SingleDuctVAVHeatCoolReheatAirTerminal_MinFlowTurnDown }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); // clear idf errors // setup variables for VAV Reheat VS Fan int SysNum = 1; int ZoneNum = 1; @@ -1580,6 +1583,7 @@ TEST_F(EnergyPlusFixture, SingleDuctVAVReheatVSFan_DamperPositionTest) }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); // clear idf errors // setup variables for VAV Reheat VS Fan int SysNum = 1; int ZoneNum = 1; @@ -1726,6 +1730,7 @@ TEST_F(EnergyPlusFixture, VAVHeatCoolReheatAirTerminal_ZoneOAVolumeFlowRateTest) }); ASSERT_TRUE(process_idf(idf_objects)); + compare_err_stream_substring("", true); // clear idf errors // setup variables for VAV HeatCoolReheat int SysNum = 1; int ZoneNum = 1; diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc index 4430614be84..6fb85c4a598 100644 --- a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc +++ b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc @@ -4965,7 +4965,6 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimVRFfluidCntrl_ATMInletSi state->dataGlobal->TimeStep = 1; state->dataGlobal->MinutesPerTimeStep = 60; ProcessScheduleInput(*state); // read schedules - InitializePsychRoutines(*state); OutputReportPredefined::SetPredefinedTables(*state); GetZoneData(*state, ErrorsFound); diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc index 5e934625bac..030a59f03c3 100644 --- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc @@ -54,11 +54,13 @@ #include #include #include +#include namespace EnergyPlus { TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataSize->ZoneEqSizing.allocate(1); state->dataEnvrn->StdRhoAir = 1.2; diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc index 7e347403289..cd566a87910 100644 --- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc @@ -53,11 +53,13 @@ #include #include #include +#include namespace EnergyPlus { TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc index 42a4947212c..e38613176a6 100644 --- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc @@ -52,11 +52,13 @@ #include #include #include +#include namespace EnergyPlus { TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; static constexpr std::string_view routineName("HeatingWaterDesCoilLoadUsedForUASizingGauntlet"); diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc index 138d86d8676..f6246b15d7b 100644 --- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc @@ -52,11 +52,13 @@ #include #include #include +#include namespace EnergyPlus { TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc index c129056b3d1..4d7e69689e7 100644 --- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc @@ -52,11 +52,13 @@ #include #include #include +#include namespace EnergyPlus { TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; static constexpr std::string_view routineName("WaterHeatingCapacitySizingGauntlet"); diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc index b430530084b..32448df55af 100644 --- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc @@ -52,6 +52,7 @@ #include #include #include +#include #include #include @@ -59,6 +60,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet) { + FluidProperties::GetFluidPropertiesData(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc index 19baffc169c..7d765db3e0f 100644 --- a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc +++ b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc @@ -71,6 +71,7 @@ using namespace EnergyPlus::Psychrometrics; TEST_F(EnergyPlusFixture, Boiler_HotWaterSizingTest) { + state->init_state(*state); // unit test for autosizing boiler nominal capacity in Boiler:HotWater state->dataBoilers->Boiler.allocate(1); // Hardsized Hot Water Boiler @@ -115,6 +116,7 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterSizingTest) } TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) { + state->init_state(*state); // unit test for checking hot water temperature for autosizing // boiler nominal capacity in Boiler:HotWater state->dataBoilers->Boiler.allocate(1); diff --git a/tst/EnergyPlus/unit/ChillerElectricEIR.unit.cc b/tst/EnergyPlus/unit/ChillerElectricEIR.unit.cc index b78b840f5e9..c3a513a1d79 100644 --- a/tst/EnergyPlus/unit/ChillerElectricEIR.unit.cc +++ b/tst/EnergyPlus/unit/ChillerElectricEIR.unit.cc @@ -92,6 +92,7 @@ TEST_F(EnergyPlusFixture, ChillerElectricEIR_TestOutletNodeConditions) TEST_F(EnergyPlusFixture, ElectricEIRChiller_HeatRecoveryAutosizeTest) { + state->init_state(*state); // unit test for autosizing heat recovery in Chiller:Electric:EIR state->dataChillerElectricEIR->ElectricEIRChiller.allocate(1); auto &thisEIR = state->dataChillerElectricEIR->ElectricEIRChiller(1); @@ -143,11 +144,6 @@ TEST_F(EnergyPlusFixture, ChillerElectricEIR_AirCooledChiller) state->dataPlnt->TotNumLoops = 2; state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = 1.20; - state->dataGlobal->NumOfTimeStepInHour = 1; - state->dataGlobal->TimeStep = 1; - state->dataGlobal->MinutesPerTimeStep = 60; - - Psychrometrics::InitializePsychRoutines(*state); std::string const idf_objects = delimited_string({ "Chiller:Electric:EIR,", @@ -193,6 +189,9 @@ TEST_F(EnergyPlusFixture, ChillerElectricEIR_AirCooledChiller) EXPECT_TRUE(process_idf(idf_objects, false)); + state->dataGlobal->NumOfTimeStepInHour = 1; + state->dataGlobal->TimeStep = 1; + state->dataGlobal->MinutesPerTimeStep = 60; state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops); state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops); for (int l = 1; l <= state->dataPlnt->TotNumLoops; ++l) { diff --git a/tst/EnergyPlus/unit/DOASEffectOnZoneSizing.unit.cc b/tst/EnergyPlus/unit/DOASEffectOnZoneSizing.unit.cc index bbf74d85e25..1bbf38ea6b6 100644 --- a/tst/EnergyPlus/unit/DOASEffectOnZoneSizing.unit.cc +++ b/tst/EnergyPlus/unit/DOASEffectOnZoneSizing.unit.cc @@ -139,7 +139,7 @@ TEST_F(EnergyPlusFixture, DOASEffectOnZoneSizing_CalcDOASSupCondsForSizing) TEST_F(EnergyPlusFixture, DOASEffectOnZoneSizing_SizeZoneEquipment) { - + state->init_state(*state); state->dataLoopNodes->Node.allocate(10); state->dataSize->ZoneEqSizing.allocate(2); state->dataHeatBal->Zone.allocate(2); diff --git a/tst/EnergyPlus/unit/DXCoils.unit.cc b/tst/EnergyPlus/unit/DXCoils.unit.cc index 98d38f6f197..ac81bf44f39 100644 --- a/tst/EnergyPlus/unit/DXCoils.unit.cc +++ b/tst/EnergyPlus/unit/DXCoils.unit.cc @@ -4634,7 +4634,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput) DX Cooling Coil AHRI 2023 Standard Rating Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, 31156.1, 3.73, 12.72, 15.17, 15.98, 15.0 )EIO"; replace_pipes_with_spaces(clg_coil_eio_output); - EXPECT_TRUE(compare_eio_stream(clg_coil_eio_output, true)); + EXPECT_TRUE(compare_eio_stream_substring(clg_coil_eio_output, true)); // check multi-speed DX heating coil EXPECT_EQ("ASHP HTG COIL", state->dataDXCoils->DXCoil(2).Name); diff --git a/tst/EnergyPlus/unit/EvaporativeFluidCoolers.unit.cc b/tst/EnergyPlus/unit/EvaporativeFluidCoolers.unit.cc index 22ed2dd947a..1238b47808c 100644 --- a/tst/EnergyPlus/unit/EvaporativeFluidCoolers.unit.cc +++ b/tst/EnergyPlus/unit/EvaporativeFluidCoolers.unit.cc @@ -71,6 +71,7 @@ namespace EnergyPlus { TEST_F(EnergyPlusFixture, EvapFluidCoolerSpecs_getDesignCapacitiesTest) { + state->init_state(*state); Real64 MaxLoad; Real64 MinLoad; Real64 OptLoad; diff --git a/tst/EnergyPlus/unit/FaultsManager.unit.cc b/tst/EnergyPlus/unit/FaultsManager.unit.cc index 10cfc08e8a3..ad199ffcd75 100644 --- a/tst/EnergyPlus/unit/FaultsManager.unit.cc +++ b/tst/EnergyPlus/unit/FaultsManager.unit.cc @@ -158,7 +158,7 @@ TEST_F(EnergyPlusFixture, FaultsManager_FaultFoulingAirFilters_CheckFaultyAirFil "ScheduleTypeLimits,", " Fraction, !- Name", " 0, !- Lower Limit Value", - " 1, !- Upper Limit Value", + " 1.5, !- Upper Limit Value", " Continuous; !- Numeric Type", "ScheduleTypeLimits,", @@ -245,7 +245,7 @@ TEST_F(EnergyPlusFixture, FaultsManager_FaultFoulingAirFilters_CheckFaultyAirFil "ScheduleTypeLimits,", " Fraction, !- Name", " 0, !- Lower Limit Value", - " 1, !- Upper Limit Value", + " 1.5, !- Upper Limit Value", " Continuous; !- Numeric Type", "ScheduleTypeLimits,", diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc index 43e61139917..44c416ad6bb 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc @@ -184,6 +184,15 @@ bool EnergyPlusFixture::compare_eio_stream(std::string const &expected_string, b return are_equal; } +bool EnergyPlusFixture::compare_eio_stream_substring(std::string const &search_string, bool reset_stream) +{ + auto const stream_str = state->files.eio.get_output(); + bool const found = stream_str.find(search_string) != std::string::npos; + EXPECT_TRUE(found); + if (reset_stream) state->files.eio.open_as_stringstream(); + return found; +} + bool EnergyPlusFixture::compare_mtr_stream(std::string const &expected_string, bool reset_stream) { auto const stream_str = state->files.mtr.get_output(); @@ -307,6 +316,9 @@ bool EnergyPlusFixture::process_idf(std::string_view const idf_snippet, bool use inputProcessor->epJSON = inputProcessor->idf_parser->decode(idf_snippet, inputProcessor->schema(), success); // Add common objects that will trigger a warning if not present + if (inputProcessor->epJSON.find("Timestep") == inputProcessor->epJSON.end()) { + inputProcessor->epJSON["Timestep"] = {{"", {{"idf_order", 0}, {"number_of_timesteps_per_hour", 4}}}}; + } if (inputProcessor->epJSON.find("Version") == inputProcessor->epJSON.end()) { inputProcessor->epJSON["Version"] = {{"", {{"idf_order", 0}, {"version_identifier", DataStringGlobals::MatchVersion}}}}; } @@ -348,9 +360,7 @@ bool EnergyPlusFixture::process_idf(std::string_view const idf_snippet, bool use inputProcessor->initializeMaps(); SimulationManager::PostIPProcessing(*state); - - FluidProperties::GetFluidPropertiesData(*state); - state->dataFluidProps->GetInput = false; + state->init_state(*state); if (state->dataSQLiteProcedures->sqlite) { bool writeOutputToSQLite = false; diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.hh b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.hh index b3b8497b049..350878d18c7 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.hh +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.hh @@ -171,6 +171,13 @@ protected: // Will return true if string matches the stream and false if it does not bool compare_eio_stream(std::string const &expected_string, bool reset_stream = true); + // Check if EIO string contains a substring. The default is to reset the EIO stream after every call. + // It is easier to test successive functions if the EIO stream is 'empty' before the next call. + // This calls EXPECT_* within the function as well as returns a boolean so you can call [ASSERT/EXPECT]_[TRUE/FALSE] depending + // if it makes sense for the unit test to continue after returning from function. + // Will return true if string matches the stream and false if it does not + bool compare_eio_stream_substring(std::string const &expected_string, bool reset_stream = true); + // Compare an expected string against the MTR stream. The default is to reset the MTR stream after every call. // It is easier to test successive functions if the MTR stream is 'empty' before the next call. // This calls EXPECT_* within the function as well as returns a boolean so you can call [ASSERT/EXPECT]_[TRUE/FALSE] depending diff --git a/tst/EnergyPlus/unit/Furnaces.unit.cc b/tst/EnergyPlus/unit/Furnaces.unit.cc index 7ea94177f89..c98b7c9e906 100644 --- a/tst/EnergyPlus/unit/Furnaces.unit.cc +++ b/tst/EnergyPlus/unit/Furnaces.unit.cc @@ -87,6 +87,7 @@ namespace EnergyPlus { TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest) { + state->init_state(*state); int FurnaceNum(1); Real64 OnOffAirFlowRatio; // This is a return value Real64 PartLoadRatio(1.0); diff --git a/tst/EnergyPlus/unit/GroundHeatExchangers.unit.cc b/tst/EnergyPlus/unit/GroundHeatExchangers.unit.cc index 13b0fb47b1f..cbb8b7c7eb3 100644 --- a/tst/EnergyPlus/unit/GroundHeatExchangers.unit.cc +++ b/tst/EnergyPlus/unit/GroundHeatExchangers.unit.cc @@ -178,6 +178,7 @@ TEST_F(EnergyPlusFixture, GroundHeatExchangerTest_System_GetGFunc) TEST_F(EnergyPlusFixture, GroundHeatExchangerTest_Slinky_CalcHXResistance) { + state->init_state(*state); // Initializations GLHESlinky thisGLHE; diff --git a/tst/EnergyPlus/unit/HVACInterfaceManager.unit.cc b/tst/EnergyPlus/unit/HVACInterfaceManager.unit.cc index 43a0f965845..2bd9dbce437 100644 --- a/tst/EnergyPlus/unit/HVACInterfaceManager.unit.cc +++ b/tst/EnergyPlus/unit/HVACInterfaceManager.unit.cc @@ -67,6 +67,7 @@ namespace EnergyPlus { TEST_F(EnergyPlusFixture, ExcessiveHeatStorage_Test) { + state->init_state(*state); using namespace DataPlant; using namespace HVACInterfaceManager; Real64 TankOutletTemp; diff --git a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc index d4a4eff313c..11e18252587 100644 --- a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc @@ -1458,7 +1458,7 @@ TEST_F(EnergyPlusFixture, HVACMultiSpeedHeatPump_ReportVariableInitTest) TEST_F(EnergyPlusFixture, HVACMultiSpeedHeatPump_HeatRecoveryTest) { - + state->init_state(*state); state->dataLoopNodes->Node.allocate(2); state->dataHVACMultiSpdHP->MSHeatPump.allocate(1); int HeatRecInNode(1); diff --git a/tst/EnergyPlus/unit/HVACSizingSimulationManager.unit.cc b/tst/EnergyPlus/unit/HVACSizingSimulationManager.unit.cc index d0b10dc7689..7fa8712c0ae 100644 --- a/tst/EnergyPlus/unit/HVACSizingSimulationManager.unit.cc +++ b/tst/EnergyPlus/unit/HVACSizingSimulationManager.unit.cc @@ -56,6 +56,7 @@ #include #include #include +#include #include #include #include @@ -136,6 +137,8 @@ class HVACSizingSimulationManagerTest : public EnergyPlusFixture TEST_F(HVACSizingSimulationManagerTest, WeatherFileDaysTest3) { + FluidProperties::GetFluidPropertiesData(*state); + // this test emulates two design days and two sizing weather file days periods // calls code related to coincident plant sizing with HVAC sizing simulation // this test runs 3 system timesteps for each zone timestep @@ -370,6 +373,8 @@ TEST_F(HVACSizingSimulationManagerTest, WeatherFileDaysTest3) TEST_F(HVACSizingSimulationManagerTest, TopDownTestSysTimestep3) { + FluidProperties::GetFluidPropertiesData(*state); + // this test emulates two design days and calls nearly all the OO code related // to coincident plant sizing with HVAC sizing simulation // this test runs 3 system timesteps for each zone timestep @@ -515,6 +520,9 @@ TEST_F(HVACSizingSimulationManagerTest, TopDownTestSysTimestep3) TEST_F(HVACSizingSimulationManagerTest, TopDownTestSysTimestep1) { + + FluidProperties::GetFluidPropertiesData(*state); + // this test emulates two design days and calls nearly all the OO code related // to coincident plant sizing with HVAC sizing simulation // this test runs 1 system timestep for each zone timestep @@ -603,6 +611,9 @@ TEST_F(HVACSizingSimulationManagerTest, TopDownTestSysTimestep1) TEST_F(HVACSizingSimulationManagerTest, VarySysTimesteps) { + + FluidProperties::GetFluidPropertiesData(*state); + // this test emulates two design days and calls nearly all the OO code related // to coincident plant sizing with HVAC sizing simulation // this test run varies the system timestep some to test irregular diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index e672738732c..2ad2ae4ea5f 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -8282,7 +8282,7 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater) { // PURPOSE OF THE TEST: // checks VRF terminal units supplemental hot water heating coil calculation - + state->init_state(*state); VRFTerminalUnitEquipment thisVRFTU; int VRFTUNum(1); @@ -8402,6 +8402,7 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilSteam) // PURPOSE OF THE TEST: // checks VRF terminal units supplemental steam heating coil calculation + state->init_state(*state); VRFTerminalUnitEquipment thisVRFTU; int VRFTUNum(1); diff --git a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc index 1d92e5a3a85..2c3f06b34fd 100644 --- a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc +++ b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc @@ -77,6 +77,7 @@ using namespace DataPlant; TEST_F(EnergyPlusFixture, HWBaseboardRadiator_CalcHWBaseboard) { + state->init_state(*state); Real64 LoadMet; int BBNum; diff --git a/tst/EnergyPlus/unit/Humidifiers.unit.cc b/tst/EnergyPlus/unit/Humidifiers.unit.cc index af7ad5d7796..c37958c73c6 100644 --- a/tst/EnergyPlus/unit/Humidifiers.unit.cc +++ b/tst/EnergyPlus/unit/Humidifiers.unit.cc @@ -71,6 +71,7 @@ namespace EnergyPlus { TEST_F(EnergyPlusFixture, Humidifiers_Sizing) { + state->init_state(*state); state->dataSize->SysSizingRunDone = true; state->dataSize->CurSysNum = 1; state->dataHumidifiers->NumElecSteamHums = 0; @@ -106,6 +107,7 @@ TEST_F(EnergyPlusFixture, Humidifiers_Sizing) TEST_F(EnergyPlusFixture, Humidifiers_AutoSizing) { + state->init_state(*state); state->dataSize->SysSizingRunDone = true; state->dataSize->CurSysNum = 1; state->dataHumidifiers->NumElecSteamHums = 0; @@ -146,6 +148,7 @@ TEST_F(EnergyPlusFixture, Humidifiers_AutoSizing) TEST_F(EnergyPlusFixture, Humidifiers_EnergyUse) { + state->init_state(*state); HumidifierData thisHum; state->dataHVACGlobal->TimeStepSys = 0.25; diff --git a/tst/EnergyPlus/unit/InputProcessor.unit.cc b/tst/EnergyPlus/unit/InputProcessor.unit.cc index 19b73256320..8e46bd4100a 100644 --- a/tst/EnergyPlus/unit/InputProcessor.unit.cc +++ b/tst/EnergyPlus/unit/InputProcessor.unit.cc @@ -223,6 +223,9 @@ TEST_F(InputProcessorFixture, decode_encode_1) " Relative,", " Relative;", "", + "Timestep,", + " 4;", + "", "Version,", " " + DataStringGlobals::MatchVersion + ";", ""}); @@ -268,6 +271,9 @@ TEST_F(InputProcessorFixture, decode_encode_2) " Relative,", " Relative;", "", + "Timestep,", + " 4;", + "", "Version,", " " + DataStringGlobals::MatchVersion + ";", "", @@ -335,6 +341,9 @@ TEST_F(InputProcessorFixture, decode_encode_3) " ,", " 10;", "", + "Timestep,", + " 4;", + "", "Version,", " " + DataStringGlobals::MatchVersion + ";", ""})); @@ -367,6 +376,9 @@ TEST_F(InputProcessorFixture, byte_order_mark) " Relative,", " Relative;", "", + "Timestep,", + " 4;", + "", "Version,", " " + DataStringGlobals::MatchVersion + ";", ""})); @@ -548,6 +560,7 @@ TEST_F(InputProcessorFixture, parse_bad_utf_8_json_2) "\"vertex_entry_direction\":\"Counterclockwise\"" "}" "}," + "\"Timestep\":{\"\":{\"idf_order\":0,\"number_of_timesteps_per_hour\":4}}," "\"Version\":{" "\"\":{" "\"idf_order\":0," @@ -596,6 +609,7 @@ TEST_F(InputProcessorFixture, parse_bad_utf_8_json_3) "\"vertex_entry_direction\":\"Counterclockwise\"" "}" "}," + "\"Timestep\":{\"\":{\"idf_order\":0,\"number_of_timesteps_per_hour\":4}}," "\"Version\":{" "\"\":{" "\"idf_order\":0," @@ -928,6 +942,9 @@ TEST_F(InputProcessorFixture, parse_idf_extensible_blank_extensibles) " Relative,", " Relative;", "", + "Timestep,", + " 4;", + "", "Version,", " " + DataStringGlobals::MatchVersion + ";", ""})); @@ -4201,6 +4218,11 @@ TEST_F(InputProcessorFixture, reportIDFRecordsStats_basic) { std::string const idf_objects = delimited_string({ + // 1 fields with default, 0 Autosizable, 0 Autocalculatable + // 0 fields defaulted , 0 Autosized , 0 Autocalculated + "Timestep,", + " 4;", // Has a default + // 1 fields with default, 0 Autosizable, 0 Autocalculatable // 0 fields defaulted , 0 Autosized , 0 Autocalculated "Version,", @@ -4283,11 +4305,11 @@ TEST_F(InputProcessorFixture, reportIDFRecordsStats_basic) state->dataInputProcessing->inputProcessor->reportIDFRecordsStats(*state); // TOTAL: - // 36 fields with defaults, 6 Autosizable, 3 Autocalculatable + // 37 fields with defaults, 6 Autosizable, 3 Autocalculatable // 11 fields defaulted , 4 Autosized , 2 Autocalculated - EXPECT_EQ(4, state->dataOutput->iNumberOfRecords); // Number of IDF Records (=Objects) - EXPECT_EQ(36, state->dataOutput->iTotalFieldsWithDefaults); // Total number of fields that could be defaulted + EXPECT_EQ(5, state->dataOutput->iNumberOfRecords); // Number of IDF Records (=Objects) + EXPECT_EQ(37, state->dataOutput->iTotalFieldsWithDefaults); // Total number of fields that could be defaulted EXPECT_EQ(6, state->dataOutput->iTotalAutoSizableFields); // Total number of autosizeable fields EXPECT_EQ(3, state->dataOutput->iTotalAutoCalculatableFields); // Total number of autocalculatable fields EXPECT_EQ(11, state->dataOutput->iNumberOfDefaultedFields); // Number of defaulted fields in IDF @@ -4300,6 +4322,11 @@ TEST_F(InputProcessorFixture, reportIDFRecordsStats_extensible_fields) std::string const idf_objects = delimited_string({ + // 1 fields with default, 0 Autosizable, 0 Autocalculatable + // 0 fields defaulted , 0 Autosized , 0 Autocalculated + "Timestep,", + " 4;", // Has a default + // 1 fields with default, 0 Autosizable, 0 Autocalculatable // 0 fields defaulted , 0 Autosized , 0 Autocalculated "Version,", @@ -4356,11 +4383,11 @@ TEST_F(InputProcessorFixture, reportIDFRecordsStats_extensible_fields) state->dataInputProcessing->inputProcessor->reportIDFRecordsStats(*state); // TOTAL: - // 15 fields with defaults, 0 Autosizable, 0 Autocalculatable + // 16 fields with defaults, 0 Autosizable, 0 Autocalculatable // 2 fields defaulted , 0 Autosized , 0 Autocalculated - EXPECT_EQ(4, state->dataOutput->iNumberOfRecords); // Number of IDF Records (=Objects) - EXPECT_EQ(15, state->dataOutput->iTotalFieldsWithDefaults); // Total number of fields that could be defaulted + EXPECT_EQ(5, state->dataOutput->iNumberOfRecords); // Number of IDF Records (=Objects) + EXPECT_EQ(16, state->dataOutput->iTotalFieldsWithDefaults); // Total number of fields that could be defaulted EXPECT_EQ(0, state->dataOutput->iTotalAutoSizableFields); // Total number of autosizeable fields EXPECT_EQ(0, state->dataOutput->iTotalAutoCalculatableFields); // Total number of autocalculatable fields EXPECT_EQ(2, state->dataOutput->iNumberOfDefaultedFields); // Number of defaulted fields in IDF diff --git a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc index fd592fbe9ab..12513ddf139 100644 --- a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc +++ b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc @@ -206,6 +206,7 @@ TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantElectric) TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantVariableFlow) { + FluidProperties::GetFluidPropertiesData(*state); SystemType = LowTempRadiantSystem::SystemType::HydronicSystem; state->dataLowTempRadSys->HydrRadSys(RadSysNum).Name = "LowTempVarFlow 1"; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ZonePtr = 1; @@ -299,6 +300,7 @@ TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantVariableFlow) TEST_F(LowTempRadiantSystemTest, SizeCapacityLowTempRadiantVariableFlow) { + FluidProperties::GetFluidPropertiesData(*state); SystemType = LowTempRadiantSystem::SystemType::HydronicSystem; state->dataLowTempRadSys->HydrRadSys(RadSysNum).Name = "LowTempVarFlow 1"; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ZonePtr = 1; @@ -375,6 +377,7 @@ TEST_F(LowTempRadiantSystemTest, SizeCapacityLowTempRadiantVariableFlow) TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantConstantFlow) { + FluidProperties::GetFluidPropertiesData(*state); SystemType = LowTempRadiantSystem::SystemType::ConstantFlowSystem; state->dataLowTempRadSys->CFloRadSys(RadSysNum).Name = "LowTempConstantFlow 1"; state->dataLowTempRadSys->CFloRadSys(RadSysNum).ZonePtr = 1; @@ -2596,6 +2599,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) Real64 Density; Real64 Cp; + FluidProperties::GetFluidPropertiesData(*state); SystemType = LowTempRadiantSystem::SystemType::ConstantFlowSystem; state->dataLowTempRadSys->CFloRadSys(RadSysNum).Name = "LowTempConstantFlow"; @@ -2686,6 +2690,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadCalcRadSysHXEffectTermTest) Real64 TubeDiameter; Real64 HXEffectFuncResult; int SurfNum; + FluidProperties::GetFluidPropertiesData(*state); // Set values of items that will stay constant for all calls to HX Effectiveness function RadSysNum = 1; diff --git a/tst/EnergyPlus/unit/MixedAir.unit.cc b/tst/EnergyPlus/unit/MixedAir.unit.cc index 0b6f721de7b..34ecef54b8d 100644 --- a/tst/EnergyPlus/unit/MixedAir.unit.cc +++ b/tst/EnergyPlus/unit/MixedAir.unit.cc @@ -6468,6 +6468,7 @@ TEST_F(EnergyPlusFixture, CO2ControlDesignOARateTest) ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->CurrentTime = 0.25; state->dataContaminantBalance->ContaminantControlledZone.allocate(1); state->dataContaminantBalance->ContaminantControlledZone(1).AvaiSchedPtr = 4; state->dataContaminantBalance->ContaminantControlledZone(1).SPSchedIndex = 5; @@ -6565,7 +6566,7 @@ TEST_F(EnergyPlusFixture, CO2ControlDesignOARateTest) " ** ~~~ ** Environment=, at Simulation time= 00:00 - 00:00", }); - EXPECT_TRUE(compare_err_stream(error_string, true)); + EXPECT_TRUE(compare_err_stream_substring(error_string, true)); state->dataAirLoop->AirLoopControlInfo.deallocate(); state->dataSize->OARequirements.deallocate(); diff --git a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc index fe22f162eb7..d49a85525c4 100644 --- a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc +++ b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc @@ -289,6 +289,7 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_AutoSize) ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->CurrentTime = 0.25; state->dataGlobal->BeginEnvrnFlag = true; state->dataSize->CurZoneEqNum = 1; state->dataEnvrn->OutBaroPress = 101325; // sea level @@ -365,6 +366,8 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_AutoSize) EXPECT_DOUBLE_EQ(SAFanPower, 75.0); EXPECT_DOUBLE_EQ(EAFanPower, 75.0); EXPECT_DOUBLE_EQ(SAFanPower + EAFanPower, state->dataOutdoorAirUnit->OutAirUnit(OAUnitNum).ElecFanRate); + compare_err_stream_substring("", true); + EXPECT_TRUE(compare_err_stream("", true)); // #6173 state->dataOutdoorAirUnit->OutAirUnit(OAUnitNum).ExtAirMassFlow = 0.0; diff --git a/tst/EnergyPlus/unit/OutputFiles.unit.cc b/tst/EnergyPlus/unit/OutputFiles.unit.cc index 6d04767db4b..e0417086a8d 100644 --- a/tst/EnergyPlus/unit/OutputFiles.unit.cc +++ b/tst/EnergyPlus/unit/OutputFiles.unit.cc @@ -276,7 +276,6 @@ TEST_F(EnergyPlusFixture, OutputControlFiles) " ** ~~~ ** See InputOutputReference document for more details.", " ************* Object=Building=Bldg", " ** ~~~ ** Object=GlobalGeometryRules", - " ** ~~~ ** Object=Version", }); compare_err_stream(expected_error); diff --git a/tst/EnergyPlus/unit/OutputProcessor.unit.cc b/tst/EnergyPlus/unit/OutputProcessor.unit.cc index 1411183733c..59b8fe5cafe 100644 --- a/tst/EnergyPlus/unit/OutputProcessor.unit.cc +++ b/tst/EnergyPlus/unit/OutputProcessor.unit.cc @@ -3740,6 +3740,7 @@ namespace OutputProcessor { ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->TimeStep = 4; state->dataGlobal->DayOfSim = 365; state->dataGlobal->DayOfSimChr = "365"; state->dataEnvrn->Month = 12; @@ -4029,6 +4030,7 @@ namespace OutputProcessor { ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->TimeStep = 4; state->dataGlobal->DayOfSim = 365; state->dataGlobal->DayOfSimChr = "365"; state->dataEnvrn->Month = 12; @@ -4571,6 +4573,7 @@ namespace OutputProcessor { ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->TimeStep = 4; state->dataGlobal->DayOfSim = 365; state->dataGlobal->DayOfSimChr = "365"; state->dataEnvrn->Month = 12; diff --git a/tst/EnergyPlus/unit/Pipes.unit.cc b/tst/EnergyPlus/unit/Pipes.unit.cc index 6c4163b12d6..27057b9fef4 100644 --- a/tst/EnergyPlus/unit/Pipes.unit.cc +++ b/tst/EnergyPlus/unit/Pipes.unit.cc @@ -82,7 +82,7 @@ TEST_F(EnergyPlusFixture, TestPipesInput) TEST_F(EnergyPlusFixture, CalcPipeHeatTransCoef) { - + state->init_state(*state); state->dataPlnt->TotNumLoops = 1; state->dataPlnt->PlantLoop.allocate(1); state->dataLoopNodes->Node.allocate(2); diff --git a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc index 913657fa1d0..4cdfdf1dea1 100644 --- a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc +++ b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc @@ -62,6 +62,7 @@ using namespace EnergyPlus; TEST_F(EnergyPlusFixture, ChillerHeater_Autosize) { + state->init_state(*state); // Allocate One Wrapper with One module (=distinct ChillerHeaterPerformance:Electric:EIR) // but with a number of identical number module of 2 in CentralHeatPumpSystem int NumWrappers = 1; diff --git a/tst/EnergyPlus/unit/PlantChillers.unit.cc b/tst/EnergyPlus/unit/PlantChillers.unit.cc index 5e39725b141..c79b4fc5ad2 100644 --- a/tst/EnergyPlus/unit/PlantChillers.unit.cc +++ b/tst/EnergyPlus/unit/PlantChillers.unit.cc @@ -62,6 +62,7 @@ using namespace PlantChillers; TEST_F(EnergyPlusFixture, GTChiller_HeatRecoveryAutosizeTest) { + state->init_state(*state); // unit test for autosizing heat recovery in Chiller:CombustionTurbine state->dataPlantChillers->GTChiller.allocate(1); @@ -99,6 +100,7 @@ TEST_F(EnergyPlusFixture, GTChiller_HeatRecoveryAutosizeTest) TEST_F(EnergyPlusFixture, EngineDrivenChiller_HeatRecoveryAutosizeTest) { + state->init_state(*state); // unit test for autosizing heat recovery in Chiller:EngineDriven state->dataPlantChillers->EngineDrivenChiller.allocate(1); diff --git a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc index 67142450ce6..79596369112 100644 --- a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc +++ b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc @@ -122,6 +122,7 @@ TEST_F(EnergyPlusFixture, LoadProfile_GetInput) TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Waterloop) { + state->init_state(*state); state->dataPlnt->PlantLoop.allocate(1); state->dataLoopNodes->Node.allocate(2); state->dataPlantLoadProfile->PlantProfile.allocate(1); @@ -190,6 +191,7 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Waterloop) TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Steamloop) { + state->init_state(*state); state->dataPlnt->PlantLoop.allocate(1); state->dataLoopNodes->Node.allocate(2); state->dataPlantLoadProfile->PlantProfile.allocate(1); diff --git a/tst/EnergyPlus/unit/PlantManager.unit.cc b/tst/EnergyPlus/unit/PlantManager.unit.cc index 6c4dca1e636..354af3d518d 100644 --- a/tst/EnergyPlus/unit/PlantManager.unit.cc +++ b/tst/EnergyPlus/unit/PlantManager.unit.cc @@ -75,6 +75,7 @@ namespace PlantManager { TEST_F(EnergyPlusFixture, PlantManager_SizePlantLoopTest) { + state->init_state(*state); state->dataPlnt->PlantLoop.allocate(1); state->dataPlnt->PlantLoop(1).VolumeWasAutoSized = true; state->dataPlnt->PlantLoop(1).MaxVolFlowRate = 5; diff --git a/tst/EnergyPlus/unit/PlantUtilities.unit.cc b/tst/EnergyPlus/unit/PlantUtilities.unit.cc index 5b0e985817d..8ac1aa0055b 100644 --- a/tst/EnergyPlus/unit/PlantUtilities.unit.cc +++ b/tst/EnergyPlus/unit/PlantUtilities.unit.cc @@ -57,6 +57,7 @@ #include "Fixtures/EnergyPlusFixture.hh" #include #include +#include #include #include @@ -89,6 +90,7 @@ TEST_F(EnergyPlusFixture, PlantUtilities_RegisterPlantCompDesignFlowTest1) TEST_F(EnergyPlusFixture, TestRegulateCondenserCompFlowReqOp) { + FluidProperties::GetFluidPropertiesData(*state); // This test captures all code paths through the RegulateCondenserCompFlowReqOp function // We only need a single component to check here state->dataPlnt->PlantLoop.allocate(1); diff --git a/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc b/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc index e807026b49e..7014ba01bed 100644 --- a/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc +++ b/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc @@ -74,6 +74,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil) int chWInletNodeNum = 9; int chWOutletNodeNum = 15; + state->init_state(*state); state->dataPlnt->TotNumLoops = 1; state->dataPlnt->PlantLoop.allocate(1); state->dataPlnt->PlantLoop(1).Name = "Chilled Water Loop"; @@ -228,6 +229,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil) int wInletNodeNum = 9; int wOutletNodeNum = 15; + state->init_state(*state); state->dataPlnt->TotNumLoops = 1; state->dataPlnt->PlantLoop.allocate(1); state->dataPlnt->PlantLoop(1).Name = "Steam Loop"; diff --git a/tst/EnergyPlus/unit/SimulationManager.unit.cc b/tst/EnergyPlus/unit/SimulationManager.unit.cc index 67d2357667c..10fda334f39 100644 --- a/tst/EnergyPlus/unit/SimulationManager.unit.cc +++ b/tst/EnergyPlus/unit/SimulationManager.unit.cc @@ -112,8 +112,6 @@ TEST_F(EnergyPlusFixture, Test_PerformancePrecisionTradeoffs_DirectSolution_Mess EXPECT_TRUE(process_idf(idf_objects, false)); - SimulationManager::GetProjectData(*state); - std::string const error_string = delimited_string({ " ** Warning ** PerformancePrecisionTradeoffs: Coil Direct Solution simulation is selected.", }); @@ -172,7 +170,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDebuggingData) EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); EXPECT_FALSE(state->dataReportFlag->DebugOutput); EXPECT_FALSE(state->dataReportFlag->EvenDuringWarmup); @@ -187,9 +184,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDebuggingData) " ; !- Report During Warmup", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); EXPECT_TRUE(state->dataReportFlag->DebugOutput); EXPECT_FALSE(state->dataReportFlag->EvenDuringWarmup); @@ -204,9 +201,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDebuggingData) " Yes; !- Report During Warmup", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); EXPECT_FALSE(state->dataReportFlag->DebugOutput); EXPECT_TRUE(state->dataReportFlag->EvenDuringWarmup); @@ -226,26 +223,22 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDebuggingData) " No; !- Report During Warmup", }); + state->init_state_called = false; + compare_err_stream_substring("", true); // Input processor with throw a severe, so do not use assertions EXPECT_FALSE(process_idf(idf_objects, false)); // Instead do it here, making sure to reset the stream { std::string const expectedError = delimited_string({ " ** Severe ** [Output:DebuggingData] - Object should have no more than 1 properties.", + " ** Warning ** Output:DebuggingData: More than 1 occurrence of this object found, only first will be used.", }); EXPECT_TRUE(compare_err_stream(expectedError, true)); } - SimulationManager::GetProjectData(*state); EXPECT_FALSE(state->dataReportFlag->DebugOutput); EXPECT_TRUE(state->dataReportFlag->EvenDuringWarmup); - { - std::string const expectedError = delimited_string({ - " ** Warning ** Output:DebuggingData: More than 1 occurrence of this object found, only first will be used.", - }); - EXPECT_TRUE(compare_err_stream(expectedError, true)); - } } } @@ -255,10 +248,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_DefaultState) " Output:Diagnostics;", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); EXPECT_FALSE(state->dataGlobal->DisplayExtraWarnings); EXPECT_FALSE(state->dataGlobal->DisplayUnusedObjects); @@ -291,10 +283,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_SimpleCase) " DisplayAdvancedReportVariables; !- Key 2", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - EXPECT_TRUE(state->dataGlobal->DisplayAllWarnings); EXPECT_TRUE(state->dataGlobal->DisplayExtraWarnings); EXPECT_TRUE(state->dataGlobal->DisplayUnusedObjects); @@ -331,10 +322,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_AllKeys) " ReportDuringHVACSizingSimulation;", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - EXPECT_TRUE(state->dataGlobal->DisplayAllWarnings); EXPECT_TRUE(state->dataGlobal->DisplayExtraWarnings); EXPECT_TRUE(state->dataGlobal->DisplayUnusedObjects); @@ -362,16 +352,18 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_Unicity) " DisplayAllWarnings; !- Key 1", }); + state->init_state_called = false; + compare_err_stream_substring("", true); // Input processor will throw a severe, so do not use assertions EXPECT_FALSE(process_idf(idf_objects, false)); // Instead do it here, making sure to reset the stream { std::string const expectedError = delimited_string({ " ** Severe ** [Output:Diagnostics] - Object should have no more than 1 properties.", + " ** Warning ** Output:Diagnostics: More than 1 occurrence of this object found, only first will be used.", }); EXPECT_TRUE(compare_err_stream(expectedError, true)); } - SimulationManager::GetProjectData(*state); EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); EXPECT_FALSE(state->dataGlobal->DisplayExtraWarnings); @@ -386,12 +378,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_Unicity) EXPECT_FALSE(state->dataSysVars->ReportDetailedWarmupConvergence); EXPECT_FALSE(state->dataSysVars->ReportDuringHVACSizingSimulation); - { - std::string const expectedError = delimited_string({ - " ** Warning ** Output:Diagnostics: More than 1 occurrence of this object found, only first will be used.", - }); - EXPECT_TRUE(compare_err_stream(expectedError, true)); - } } TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_UndocumentedFlags) @@ -405,6 +391,7 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_UndocumentedFlags) " TimingFlag;", }); + state->init_state_called = false; // This will throw a warning in InputProcessor since these aren't supported keys, so do not use assertions EXPECT_FALSE(process_idf(idf_objects, false)); const std::string expected_warning = delimited_string({ @@ -421,8 +408,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_UndocumentedFlags) }); EXPECT_TRUE(compare_err_stream(expected_warning, true)); - SimulationManager::GetProjectData(*state); - EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); EXPECT_FALSE(state->dataGlobal->DisplayExtraWarnings); EXPECT_FALSE(state->dataGlobal->DisplayUnusedObjects); @@ -456,10 +441,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_HasEmpty) " DisplayAdvancedReportVariables; !- Key 2", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - ASSERT_NO_THROW(SimulationManager::GetProjectData(*state)); - EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); EXPECT_FALSE(state->dataGlobal->DisplayExtraWarnings); EXPECT_FALSE(state->dataGlobal->DisplayUnusedObjects); @@ -494,10 +478,9 @@ TEST_F(EnergyPlusFixture, SimulationManager_HVACSizingSimulationChoiceTest) " Yes; !- Do HVAC Sizing Simulation for Sizing Periods", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - EXPECT_TRUE(state->dataGlobal->DoHVACSizingSimulation); // get a default value EXPECT_EQ(state->dataGlobal->HVACSizingSimMaxIterations, 1); @@ -517,10 +500,9 @@ TEST_F(EnergyPlusFixture, Test_SimulationControl_ZeroSimulation) " 1; !- Maximum Number of HVAC Sizing Simulation Passes", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - ASSERT_THROW(SimulationManager::CheckForMisMatchedEnvironmentSpecifications(*state), std::runtime_error); // no error message from PerformancePrecisionTradeoffs objects // @@ -549,10 +531,9 @@ TEST_F(EnergyPlusFixture, Test_SimulationControl_PureLoadCalc) " 1; !- Maximum Number of HVAC Sizing Simulation Passes", }); + state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); - SimulationManager::GetProjectData(*state); - EXPECT_NO_THROW(SimulationManager::CheckForMisMatchedEnvironmentSpecifications(*state)); // no error message from PerformancePrecisionTradeoffs objects // diff --git a/tst/EnergyPlus/unit/StandardRatings.unit.cc b/tst/EnergyPlus/unit/StandardRatings.unit.cc index c435b75c860..406d05f688f 100644 --- a/tst/EnergyPlus/unit/StandardRatings.unit.cc +++ b/tst/EnergyPlus/unit/StandardRatings.unit.cc @@ -1202,7 +1202,7 @@ TEST_F(EnergyPlusFixture, ChillerIPLVTestWaterCooledReform) { using StandardRatings::CalcChillerIPLV; - + state->init_state(*state); // Setup a water-cooled Chiller:Electric:ReformulatedEIR chiller with reference conditions being at non-rated conditions state->dataChillerReformulatedEIR->ElecReformEIRChiller.allocate(1); state->dataChillerReformulatedEIR->ElecReformEIRChiller(1).Name = "ReformEIRChiller McQuay WSC 471kW/5.89COP/Vanes"; diff --git a/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc b/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc index 1d36b7f9d89..d4c559ceba2 100644 --- a/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc +++ b/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc @@ -3912,6 +3912,7 @@ TEST_F(EnergyPlusFixture, SurfaceGeometry_HeatTransferAlgorithmTest) bool ErrorsFound(false); std::string const idf_objects = delimited_string({ + " Timestep, 20;" " HeatBalanceAlgorithm,", " MoisturePenetrationDepthConductionTransferFunction; !- Algorithm", "Material,", diff --git a/tst/EnergyPlus/unit/SwimmingPool.unit.cc b/tst/EnergyPlus/unit/SwimmingPool.unit.cc index d6829e82b38..61d10cc5db5 100644 --- a/tst/EnergyPlus/unit/SwimmingPool.unit.cc +++ b/tst/EnergyPlus/unit/SwimmingPool.unit.cc @@ -501,6 +501,7 @@ TEST_F(EnergyPlusFixture, SwimmingPool_reportTest) Real64 constexpr closeEnough = 0.000001; SwimmingPoolData myPool; + state->init_state(*state); // Test Data myPool.Name = "This Pool"; myPool.SurfacePtr = 1; diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 427ab85de53..ca3e396a734 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -296,6 +296,8 @@ class AirloopUnitarySysTest : public EnergyPlusFixture TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) { + FluidProperties::GetFluidPropertiesData(*state); + // Set up raw water coil sizes as coil-on-branch configuration then // test against sizing of same water coils in UnitarySystem @@ -5479,6 +5481,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_ConfirmUnitarySystemSizingTest) TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) { + FluidProperties::GetFluidPropertiesData(*state); int AirLoopNum(1); bool FirstHVACIteration(false); HVAC::CompressorOp CompressorOn(HVAC::CompressorOp::On); @@ -5620,6 +5623,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) { + FluidProperties::GetFluidPropertiesData(*state); HVAC::CompressorOp CompressorOn(HVAC::CompressorOp::On); int AirLoopNum(1); bool FirstHVACIteration(false); @@ -20184,6 +20188,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop) TEST_F(AirloopUnitarySysTest, WSHPVariableSpeedCoilSizing) { + FluidProperties::GetFluidPropertiesData(*state); // test that correct CapFT inputs are used for the WSHP cooling coil state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); diff --git a/tst/EnergyPlus/unit/VAVDefMinMaxFlow.unit.cc b/tst/EnergyPlus/unit/VAVDefMinMaxFlow.unit.cc index 440eacf441d..e4307f6da2d 100644 --- a/tst/EnergyPlus/unit/VAVDefMinMaxFlow.unit.cc +++ b/tst/EnergyPlus/unit/VAVDefMinMaxFlow.unit.cc @@ -232,8 +232,10 @@ TEST_F(EnergyPlusFixture, VAVDefMinMaxFlowTestSizing1) ASSERT_TRUE(process_idf(idf_objects)); state->dataSize->FinalZoneSizing.allocate(1); + state->dataSize->FinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->NumAirTerminalSizingSpec = 1; state->dataSize->TermUnitFinalZoneSizing.allocate(1); + state->dataSize->TermUnitFinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->CalcFinalZoneSizing.allocate(1); state->dataSize->TermUnitSizing.allocate(1); GetZoneData(*state, ErrorsFound); @@ -424,7 +426,9 @@ TEST_F(EnergyPlusFixture, VAVDefMinMaxFlowTestSizing2) ASSERT_TRUE(process_idf(idf_objects)); state->dataSize->FinalZoneSizing.allocate(1); + state->dataSize->FinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->TermUnitFinalZoneSizing.allocate(1); + state->dataSize->TermUnitFinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->NumAirTerminalSizingSpec = 1; state->dataSize->CalcFinalZoneSizing.allocate(1); state->dataSize->TermUnitSizing.allocate(1); @@ -616,7 +620,9 @@ TEST_F(EnergyPlusFixture, VAVDefMinMaxFlowTestSizing3) ASSERT_TRUE(process_idf(idf_objects)); state->dataSize->FinalZoneSizing.allocate(1); + state->dataSize->FinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->TermUnitFinalZoneSizing.allocate(1); + state->dataSize->TermUnitFinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->CalcFinalZoneSizing.allocate(1); state->dataSize->TermUnitSizing.allocate(1); GetZoneData(*state, ErrorsFound); @@ -809,7 +815,9 @@ TEST_F(EnergyPlusFixture, VAVDefMinMaxFlowTestSizing4) ASSERT_TRUE(process_idf(idf_objects)); state->dataSize->FinalZoneSizing.allocate(1); + state->dataSize->FinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->TermUnitFinalZoneSizing.allocate(1); + state->dataSize->TermUnitFinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->CalcFinalZoneSizing.allocate(1); state->dataSize->TermUnitSizing.allocate(1); GetZoneData(*state, ErrorsFound); @@ -958,8 +966,10 @@ TEST_F(EnergyPlusFixture, VAVDefMinMaxFlowTestSizing5) ASSERT_TRUE(process_idf(idf_objects)); state->dataSize->FinalZoneSizing.allocate(1); + state->dataSize->FinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->NumAirTerminalSizingSpec = 1; state->dataSize->TermUnitFinalZoneSizing.allocate(1); + state->dataSize->TermUnitFinalZoneSizing(1).allocateMemberArrays(96); state->dataSize->CalcFinalZoneSizing.allocate(1); state->dataSize->TermUnitSizing.allocate(1); GetZoneData(*state, ErrorsFound); diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 7faecd4d5ec..dcc72b3ad45 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -167,6 +167,7 @@ class WaterCoilsTest : public EnergyPlusFixture TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) { + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); @@ -401,6 +402,7 @@ TEST_F(WaterCoilsTest, TdbFnHRhPbTest) TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) { + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); @@ -557,6 +559,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) { + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); @@ -716,6 +719,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) { + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); @@ -833,6 +837,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) { InitializePsychRoutines(*state); + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); ShowMessage(*state, "Begin Test: state->dataWaterCoils->WaterCoilsTest, CoilCoolingWaterSimpleSizing"); @@ -936,6 +941,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) { InitializePsychRoutines(*state); + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); ShowMessage(*state, "Begin Test: state->dataWaterCoils->WaterCoilsTest, CoilCoolingWaterDetailedSizing"); @@ -1051,6 +1057,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) { InitializePsychRoutines(*state); + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); @@ -1235,6 +1242,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) { InitializePsychRoutines(*state); + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); ShowMessage(*state, "Begin Test: state->dataWaterCoils->WaterCoilsTest, CoilHeatingWaterSimpleSizing"); @@ -1332,6 +1340,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) } TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) { + FluidProperties::GetFluidPropertiesData(*state); state->dataEnvrn->OutBaroPress = 101325.0; state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); diff --git a/tst/EnergyPlus/unit/WaterUse.unit.cc b/tst/EnergyPlus/unit/WaterUse.unit.cc index 1590fd0a900..61cc656bb85 100644 --- a/tst/EnergyPlus/unit/WaterUse.unit.cc +++ b/tst/EnergyPlus/unit/WaterUse.unit.cc @@ -417,6 +417,7 @@ TEST_F(EnergyPlusFixture, WaterUse_WaterTempWarnings) ASSERT_TRUE(process_idf(idf_objects)); + state->dataGlobal->CurrentTime = 0.25; state->dataGlobal->NumOfTimeStepInHour = 1; // must initialize this to get schedules initialized state->dataGlobal->MinutesPerTimeStep = 60; // must initialize this to get schedules initialized ScheduleManager::ProcessScheduleInput(*state); // read schedules @@ -1272,6 +1273,7 @@ TEST_F(EnergyPlusFixture, WaterUse_calcH2ODensity_Test) Real64 expectedResult; Real64 allowedTolerance = 0.001; + state->init_state(*state); // Test 1: Set the flag to false means don't recalculate. This means it wasn't set so this should be the default value. state->dataWaterUse->calcRhoH2O = false; expectedResult = 1000.0; diff --git a/tst/EnergyPlus/unit/WeatherManager.unit.cc b/tst/EnergyPlus/unit/WeatherManager.unit.cc index 5db65feba71..869b49b70ae 100644 --- a/tst/EnergyPlus/unit/WeatherManager.unit.cc +++ b/tst/EnergyPlus/unit/WeatherManager.unit.cc @@ -597,7 +597,7 @@ TEST_F(EnergyPlusFixture, WaterMainsOutputReports_CorrelationFromWeatherFileTest }); ASSERT_TRUE(process_idf(idf_objects)); - + compare_eio_stream_substring("", true); bool foundErrors(false); Weather::GetWaterMainsTemperatures(*state, foundErrors); EXPECT_FALSE(foundErrors); // expect no errors @@ -688,6 +688,7 @@ TEST_F(EnergyPlusFixture, ASHRAE_Tau2017ModelTest) bool ErrorsFound(false); state->dataEnvrn->TotDesDays = 2; + state->dataGlobal->NumOfTimeStepInHour = 0; // setup environment state state->dataWeather->Environment.allocate(state->dataEnvrn->TotDesDays); state->dataWeather->DesignDay.allocate(state->dataEnvrn->TotDesDays); @@ -1144,6 +1145,7 @@ TEST_F(EnergyPlusFixture, IRHoriz_InterpretWeatherCalculateMissingIRHoriz) bool ErrorsFound(false); state->dataEnvrn->TotDesDays = 2; + state->dataGlobal->NumOfTimeStepInHour = 0; // setup environment state state->dataWeather->Environment.allocate(state->dataEnvrn->TotDesDays); From fe336f956a7b519d78e33ee7c1a10e8bbfc1b32b Mon Sep 17 00:00:00 2001 From: rraustad Date: Thu, 27 Jun 2024 20:25:22 -0400 Subject: [PATCH 073/115] Add init_state call to API? --- src/EnergyPlus/api/func.cc | 3 ++- tst/EnergyPlus/unit/SimulationManager.unit.cc | 2 -- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/EnergyPlus/api/func.cc b/src/EnergyPlus/api/func.cc index c17d244fb16..21b11932040 100644 --- a/src/EnergyPlus/api/func.cc +++ b/src/EnergyPlus/api/func.cc @@ -61,7 +61,8 @@ void initializeFunctionalAPI(EnergyPlusState state) if (!thisState->dataInputProcessing->inputProcessor) { thisState->dataInputProcessing->inputProcessor = EnergyPlus::InputProcessor::factory(); } - EnergyPlus::Psychrometrics::InitializePsychRoutines(*thisState); + thisState->init_state(*thisState); + // this next line can be removed once InitializeGlycRoutines is added to init_state EnergyPlus::FluidProperties::InitializeGlycRoutines(); } diff --git a/tst/EnergyPlus/unit/SimulationManager.unit.cc b/tst/EnergyPlus/unit/SimulationManager.unit.cc index 10fda334f39..4f350bb4cb2 100644 --- a/tst/EnergyPlus/unit/SimulationManager.unit.cc +++ b/tst/EnergyPlus/unit/SimulationManager.unit.cc @@ -238,7 +238,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDebuggingData) EXPECT_FALSE(state->dataReportFlag->DebugOutput); EXPECT_TRUE(state->dataReportFlag->EvenDuringWarmup); - } } @@ -377,7 +376,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_Unicity) EXPECT_FALSE(state->dataEnvrn->DisplayWeatherMissingDataWarnings); EXPECT_FALSE(state->dataSysVars->ReportDetailedWarmupConvergence); EXPECT_FALSE(state->dataSysVars->ReportDuringHVACSizingSimulation); - } TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_UndocumentedFlags) From 5550a9bec648e613fc52e7705bd0c1af70b197b1 Mon Sep 17 00:00:00 2001 From: rraustad Date: Thu, 27 Jun 2024 23:29:31 -0400 Subject: [PATCH 074/115] Only call init_state in API --- src/EnergyPlus/Data/EnergyPlusData.cc | 2 +- src/EnergyPlus/SimulationManager.cc | 2 -- src/EnergyPlus/SimulationManager.hh | 1 + src/EnergyPlus/api/func.cc | 3 +-- tst/EnergyPlus/unit/OutputProcessor.unit.cc | 21 +++++++++++++++++---- 5 files changed, 20 insertions(+), 9 deletions(-) diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index d3c301a69dc..7cd7ac859ca 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -576,8 +576,8 @@ void EnergyPlusData::init_state(EnergyPlusData &state) // do this in "topological" order meaning the first to go are the // objects that do not reference any other objects, like fluids, // schedules, curves, etc. - this->dataFluidProps->init_state(state); // GetFluidPropertiesData this->dataSimulationManager->init_state(state); // GetProjectData + this->dataFluidProps->init_state(state); // GetFluidPropertiesData this->dataPsychrometrics->init_state(state); // InitializePsychRoutines this->dataAirLoop->init_state(state); diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc index c6597b1cd30..70ba13d6ddd 100644 --- a/src/EnergyPlus/SimulationManager.cc +++ b/src/EnergyPlus/SimulationManager.cc @@ -209,8 +209,6 @@ namespace SimulationManager { state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "RunPeriod:CustomRange") > 0 || state.dataSysVars->FullAnnualRun); state.dataErrTracking->AskForConnectionsReport = false; // set to false until sizing is finished - OpenOutputFiles(state); - state.init_state(state); CheckForMisMatchedEnvironmentSpecifications(state); diff --git a/src/EnergyPlus/SimulationManager.hh b/src/EnergyPlus/SimulationManager.hh index 503404e3fc0..86f23c4a5d7 100644 --- a/src/EnergyPlus/SimulationManager.hh +++ b/src/EnergyPlus/SimulationManager.hh @@ -101,6 +101,7 @@ struct SimulationManagerData : BaseGlobalStruct bool WarningOut = true; void init_state(EnergyPlusData &state) override { + SimulationManager::OpenOutputFiles(state); SimulationManager::GetProjectData(state); } diff --git a/src/EnergyPlus/api/func.cc b/src/EnergyPlus/api/func.cc index 21b11932040..24a895c961d 100644 --- a/src/EnergyPlus/api/func.cc +++ b/src/EnergyPlus/api/func.cc @@ -52,6 +52,7 @@ #include #include #include +#include #include #include @@ -62,8 +63,6 @@ void initializeFunctionalAPI(EnergyPlusState state) thisState->dataInputProcessing->inputProcessor = EnergyPlus::InputProcessor::factory(); } thisState->init_state(*thisState); - // this next line can be removed once InitializeGlycRoutines is added to init_state - EnergyPlus::FluidProperties::InitializeGlycRoutines(); } const char *apiVersionFromEPlus(EnergyPlusState) diff --git a/tst/EnergyPlus/unit/OutputProcessor.unit.cc b/tst/EnergyPlus/unit/OutputProcessor.unit.cc index 59b8fe5cafe..44ae8837d37 100644 --- a/tst/EnergyPlus/unit/OutputProcessor.unit.cc +++ b/tst/EnergyPlus/unit/OutputProcessor.unit.cc @@ -2990,7 +2990,8 @@ namespace OutputProcessor { auto reportExtendedDataResults = queryResult("SELECT * FROM ReportExtendedData;", "ReportExtendedData"); compare_eso_stream( - delimited_string({"1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", + delimited_string({"Program Version,", + "1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", "2,11,Boiler2,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", "3,11,Boiler3,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]"}, "\n")); @@ -3021,7 +3022,8 @@ namespace OutputProcessor { auto reportExtendedDataResults = queryResult("SELECT * FROM ReportExtendedData;", "ReportExtendedData"); compare_eso_stream( - delimited_string({"1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", + delimited_string({"Program Version,", + "1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", "2,11,Boiler3,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]"}, "\n")); } @@ -3052,7 +3054,8 @@ namespace OutputProcessor { auto reportExtendedDataResults = queryResult("SELECT * FROM ReportExtendedData;", "ReportExtendedData"); compare_eso_stream( - delimited_string({"1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", + delimited_string({"Program Version,", + "1,11,Boiler1,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", "2,11,Boiler2,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]", "3,11,Boiler3,Boiler NaturalGas Rate [W] !RunPeriod [Value,Min,Month,Day,Hour,Minute,Max,Month,Day,Hour,Minute]"}, "\n")); @@ -3120,6 +3123,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "1,1,Zn003:Wall001,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", "2,1,Zn003:Wall002,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", "3,1,Zn003:Wall002:Win001,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", @@ -3192,6 +3196,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "1,1,ZN003:WALL001,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", "2,1,ZN003:WALL002,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", "3,1,ZN003:WALL002:WIN001,AFN Linkage Node 1 to Node 2 Volume Flow Rate [m3/s] !TimeStep", @@ -3289,7 +3294,8 @@ namespace OutputProcessor { UpdateMeterReporting(*state); compare_mtr_stream( - delimited_string({"53,9,InteriorLights:Electricity:Zone:SPACE1 [J] !Monthly [Value,Min,Day,Hour,Minute,Max,Day,Hour,Minute]", + delimited_string({"Program Version,", + "53,9,InteriorLights:Electricity:Zone:SPACE1 [J] !Monthly [Value,Min,Day,Hour,Minute,Max,Day,Hour,Minute]", "102,9,InteriorLights:Electricity:Zone:SPACE2 [J] !Monthly [Value,Min,Day,Hour,Minute,Max,Day,Hour,Minute]", "139,9,InteriorLights:Electricity:Zone:SPACE3 [J] !Monthly [Value,Min,Day,Hour,Minute,Max,Day,Hour,Minute]", "176,9,InteriorLights:Electricity:Zone:SPACE4 [J] !Monthly [Value,Min,Day,Hour,Minute,Max,Day,Hour,Minute]", @@ -3959,6 +3965,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "1,1,Environment,Site Outdoor Air Drybulb Temperature [C] !TimeStep", "2,1,Environment,Site Outdoor Air Drybulb Temperature [C] !Hourly", "3,7,Environment,Site Outdoor Air Drybulb Temperature [C] !Daily [Value,Min,Hour,Minute,Max,Hour,Minute]", @@ -3989,6 +3996,7 @@ namespace OutputProcessor { compare_mtr_stream(delimited_string( { + "Program Version,", "7,1,Electricity:Facility [J] !TimeStep", "8,1,Electricity:Facility [J] !Hourly", "9,7,Electricity:Facility [J] !Daily [Value,Min,Hour,Minute,Max,Hour,Minute]", @@ -4257,6 +4265,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "1,1,Environment,Site Outdoor Air Drybulb Temperature [C] !Each Call", "2,1,Environment,Site Outdoor Air Drybulb Temperature [C] !TimeStep", "3,1,Environment,Site Outdoor Air Drybulb Temperature [C] !Hourly", @@ -4291,6 +4300,7 @@ namespace OutputProcessor { compare_mtr_stream(delimited_string( { + "Program Version,", "8,1,Electricity:Facility [J] !Each Call", "9,1,Electricity:Facility [J] !Hourly", "10,7,Electricity:Facility [J] !Daily [Value,Min,Hour,Minute,Max,Hour,Minute]", @@ -4534,6 +4544,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "1,1,Environment,Site Outdoor Air Drybulb Temperature [C] !Each Call", "2,1,Environment,Site Outdoor Air Drybulb Temperature [C] !TimeStep", "3,1,Environment,Site Outdoor Air Drybulb Temperature [C] !Hourly", @@ -4555,6 +4566,7 @@ namespace OutputProcessor { compare_mtr_stream(delimited_string( { + "Program Version,", "8,1,Electricity:Facility [J] !Each Call", "9,1,Electricity:Facility [J] !Hourly", "10,7,Electricity:Facility [J] !Daily [Value,Min,Hour,Minute,Max,Hour,Minute]", @@ -4631,6 +4643,7 @@ namespace OutputProcessor { compare_eso_stream(delimited_string( { + "Program Version,", "2,1,Electricity:Facility [J] !TimeStep", ",365,12,31, 0,24,50.00,60.00,Tuesday", "2,0.0", From 0a2030b33c3fcdc9ecf5f21cc1e0603b70f58c8e Mon Sep 17 00:00:00 2001 From: rraustad Date: Fri, 28 Jun 2024 00:18:54 -0400 Subject: [PATCH 075/115] clean up --- src/EnergyPlus/Data/EnergyPlusData.cc | 3 +-- src/EnergyPlus/api/func.cc | 1 - tst/EnergyPlus/unit/SimulationManager.unit.cc | 9 --------- 3 files changed, 1 insertion(+), 12 deletions(-) diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index 7cd7ac859ca..db7eed811b0 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -572,6 +572,7 @@ void EnergyPlusData::clear_state() void EnergyPlusData::init_state(EnergyPlusData &state) { if (this->init_state_called) return; + this->init_state_called = true; // The order in which we do this matters. We're going to try to // do this in "topological" order meaning the first to go are the // objects that do not reference any other objects, like fluids, @@ -825,8 +826,6 @@ void EnergyPlusData::init_state(EnergyPlusData &state) this->dataZoneEquipmentManager->init_state(state); this->dataZonePlenum->init_state(state); this->dataZoneTempPredictorCorrector->init_state(state); - - this->init_state_called = true; } } // namespace EnergyPlus diff --git a/src/EnergyPlus/api/func.cc b/src/EnergyPlus/api/func.cc index 24a895c961d..e8e4b5263b4 100644 --- a/src/EnergyPlus/api/func.cc +++ b/src/EnergyPlus/api/func.cc @@ -52,7 +52,6 @@ #include #include #include -#include #include #include diff --git a/tst/EnergyPlus/unit/SimulationManager.unit.cc b/tst/EnergyPlus/unit/SimulationManager.unit.cc index 4f350bb4cb2..954b4afae02 100644 --- a/tst/EnergyPlus/unit/SimulationManager.unit.cc +++ b/tst/EnergyPlus/unit/SimulationManager.unit.cc @@ -247,7 +247,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_DefaultState) " Output:Diagnostics;", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); @@ -282,7 +281,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_SimpleCase) " DisplayAdvancedReportVariables; !- Key 2", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_TRUE(state->dataGlobal->DisplayAllWarnings); @@ -321,7 +319,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_AllKeys) " ReportDuringHVACSizingSimulation;", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_TRUE(state->dataGlobal->DisplayAllWarnings); @@ -351,7 +348,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_Unicity) " DisplayAllWarnings; !- Key 1", }); - state->init_state_called = false; compare_err_stream_substring("", true); // Input processor will throw a severe, so do not use assertions EXPECT_FALSE(process_idf(idf_objects, false)); @@ -389,7 +385,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_UndocumentedFlags) " TimingFlag;", }); - state->init_state_called = false; // This will throw a warning in InputProcessor since these aren't supported keys, so do not use assertions EXPECT_FALSE(process_idf(idf_objects, false)); const std::string expected_warning = delimited_string({ @@ -439,7 +434,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_OutputDiagnostics_HasEmpty) " DisplayAdvancedReportVariables; !- Key 2", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_FALSE(state->dataGlobal->DisplayAllWarnings); @@ -476,7 +470,6 @@ TEST_F(EnergyPlusFixture, SimulationManager_HVACSizingSimulationChoiceTest) " Yes; !- Do HVAC Sizing Simulation for Sizing Periods", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_TRUE(state->dataGlobal->DoHVACSizingSimulation); @@ -498,7 +491,6 @@ TEST_F(EnergyPlusFixture, Test_SimulationControl_ZeroSimulation) " 1; !- Maximum Number of HVAC Sizing Simulation Passes", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); ASSERT_THROW(SimulationManager::CheckForMisMatchedEnvironmentSpecifications(*state), std::runtime_error); @@ -529,7 +521,6 @@ TEST_F(EnergyPlusFixture, Test_SimulationControl_PureLoadCalc) " 1; !- Maximum Number of HVAC Sizing Simulation Passes", }); - state->init_state_called = false; EXPECT_TRUE(process_idf(idf_objects)); EXPECT_NO_THROW(SimulationManager::CheckForMisMatchedEnvironmentSpecifications(*state)); From 342f7b396b61e44755dab00e9936e71c4d231ab7 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 28 Jun 2024 12:50:45 -0500 Subject: [PATCH 076/115] remove extra line --- tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc index 8453eeba9f0..7809725dcd9 100644 --- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc +++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc @@ -3037,7 +3037,6 @@ TEST_F(EnergyPlusFixture, VSSeriesPIUCool) EXPECT_EQ(state->dataLoopNodes->Node(thisPIU.OutAirNode).MassFlowRate, thisPIU.MaxTotAirMassFlow); } - TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit) { using namespace EnergyPlus::OutputReportPredefined; From 1ad9d9978646b28666ddcfd2034542df69976c39 Mon Sep 17 00:00:00 2001 From: rraustad Date: Fri, 28 Jun 2024 15:10:52 -0400 Subject: [PATCH 077/115] Add examples of init_state subset calls. Delete empty InitializeGlycRoutines function. --- src/EnergyPlus/FluidProperties.cc | 7 ------- src/EnergyPlus/FluidProperties.hh | 2 -- .../Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc | 2 +- .../unit/Autosizing/CoolingWaterflowSizing.unit.cc | 2 +- .../HeatingWaterDesCoilLoadUsedForUASizing.unit.cc | 2 +- .../unit/Autosizing/HeatingWaterflowSizing.unit.cc | 2 +- .../unit/Autosizing/WaterHeatingCapacitySizing.unit.cc | 2 +- .../unit/Autosizing/WaterHeatingCoilUASizing.unit.cc | 2 +- tst/EnergyPlus/unit/BoilerHotWater.unit.cc | 4 ++-- tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc | 1 - 10 files changed, 8 insertions(+), 18 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 00d23bd4893..3cd8b996ffc 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -102,11 +102,6 @@ namespace FluidProperties { // supplying the same data for concentrations of 0.0 and 1.0 only. // Temperature data has to be supplied in ascending order only. - void InitializeGlycRoutines() - { - // TODO: Delete this, the cache is now part of state and initialized with the state constructor - } - void GetFluidPropertiesData(EnergyPlusData &state) { @@ -660,8 +655,6 @@ namespace FluidProperties { cNumericFieldNames = ""; lNumericFieldBlanks = false; - InitializeGlycRoutines(); - // Check to see if there is any FluidName input. If not, this is okay as // long as the user only desires to simulate loops with water. More than // one FluidName input is not allowed. diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 9dc3180b2e7..5cf7f82a727 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -344,8 +344,6 @@ namespace FluidProperties { } }; - void InitializeGlycRoutines(); - void GetFluidPropertiesData(EnergyPlusData &state); template diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc index 030a59f03c3..993b0e623c1 100644 --- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc @@ -60,7 +60,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataSize->ZoneEqSizing.allocate(1); state->dataEnvrn->StdRhoAir = 1.2; diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc index cd566a87910..08fe992af31 100644 --- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc @@ -59,7 +59,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc index e38613176a6..ca2acf8aebc 100644 --- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc @@ -58,7 +58,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; static constexpr std::string_view routineName("HeatingWaterDesCoilLoadUsedForUASizingGauntlet"); diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc index f6246b15d7b..a7369eee5c8 100644 --- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc @@ -58,7 +58,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc index 4d7e69689e7..e7901625036 100644 --- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc @@ -58,7 +58,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; static constexpr std::string_view routineName("WaterHeatingCapacitySizingGauntlet"); diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc index 32448df55af..355a4cec876 100644 --- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc @@ -60,7 +60,7 @@ namespace EnergyPlus { TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet) { - FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProps->init_state(*state); // this global state is what would be set up by E+ currently state->dataEnvrn->StdRhoAir = 1.2; state->dataSize->ZoneEqSizing.allocate(1); diff --git a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc index 7d765db3e0f..0073f22d5b1 100644 --- a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc +++ b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc @@ -71,7 +71,7 @@ using namespace EnergyPlus::Psychrometrics; TEST_F(EnergyPlusFixture, Boiler_HotWaterSizingTest) { - state->init_state(*state); + state->dataFluidProps->init_state(*state); // unit test for autosizing boiler nominal capacity in Boiler:HotWater state->dataBoilers->Boiler.allocate(1); // Hardsized Hot Water Boiler @@ -116,7 +116,7 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterSizingTest) } TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) { - state->init_state(*state); + state->dataFluidProps->init_state(*state); // unit test for checking hot water temperature for autosizing // boiler nominal capacity in Boiler:HotWater state->dataBoilers->Boiler.allocate(1); diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc index 44c416ad6bb..3402f5892fd 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc @@ -118,7 +118,6 @@ void EnergyPlusFixture::SetUp() state->dataUtilityRoutines->outputErrorHeader = false; Psychrometrics::InitializePsychRoutines(*state); - FluidProperties::InitializeGlycRoutines(); createCoilSelectionReportObj(*state); } From 9bba9ed7eb3a77ee4bdd25a3b8cbf97504b82abb Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Fri, 28 Jun 2024 15:31:47 -0500 Subject: [PATCH 078/115] Updat IOref for new tabular reports. --- .../output-table-summaryreports.tex | 56 +++++++++++++++++-- 1 file changed, 50 insertions(+), 6 deletions(-) diff --git a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex index f352febfdaa..5eaf80ce1df 100644 --- a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex +++ b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex @@ -73,11 +73,22 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar \begin{itemize} \item - Opaque which includes all opaque surfaces and includes the name of the construction, reflectance, U-Factor, gross area, azimuth, tilt, cardinal direction. + Opaque exterior which includes all exterior opaque surfaces and includes the name of the construction, zone, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. \item - Exterior Fenestration which includes all non-opaque exterior surfaces and includes the name of the construction, areas (glass, frame, divider, single opening, multiplied openings), glass U-Factor, glass SHGC (the solar heat gain coefficient based on summer conditions), glass visible transmittance, NFRC Product Type, assembly U-Factor, assembly SHGC, assembly visible transmittance, conductance (frame, divider), indication of shade control, the name of the parent surface, azimuth, tilt, cardinal direction. + Opaque exterior which includes all exterior opaque surfaces and includes the name of the construction, zone, adjacent surface, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. +\item + Exterior Fenestration which includes all non-opaque exterior surfaces and includes the name of the construction, frame and divider name, areas (glass, frame, divider, single opening, multiplied openings), glass U-Factor, glass SHGC (the solar heat gain coefficient based on summer conditions), glass visible transmittance, NFRC Product Type, assembly U-Factor, assembly SHGC, assembly visible transmittance, conductance (frame, divider), indication of shade control, the name of the parent surface, azimuth, tilt, cardinal direction. \item Exterior Fenestration Shaded State has values shown for exterior fenestration that have a shaded state by using \hyperref[windowpropertyshadingcontrol]{WindowShadingControl} the values of the u-factor, SHGC, and visible transmittance are shown for both the glass only and the full assembly when in the shaded state. +\item + Interior Fenestration which includes the construction, areas, glass u-factor, SHGC, and visible transmittance, and the parent surface name. +\item + Exterior Door which includes the construction, u-factors, area, and the parent surface name. +\item + Interior Door which includes the construction, u-factors, area, and the parent surface name. +\item + Opaque Construction Layers includes the material layers for each construction in order. + \end{itemize} The assembly results include the effect of the frame and divider and are only produced when \hyperref[windowpropertyframeanddivider]{WindowProperty:FrameAndDivider} input object is used. In addition, the assembly columns are shown for most configurations but are not shown when using \hyperref[constructionwindowequivalentlayer]{Construction:WindowEquivalentLayer} or when using \hyperref[constructionwindowdatafile]{Construction:WindowDataFile} with a Window5DataFile.dat file. @@ -130,16 +141,31 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar Cooling Coils includes the nominal total, sensible and latent capacities, the nominal sensible heat ratio, the nominal efficiency, nominal UA value, and nominal~ surface area for each cooling coil. These values are calculated by calling the cooling coil simulation routine with the rated inlet conditions: inlet air dry bulb temperature = 26.67C, inlet air wet bulb temperature = 19.44C, inlet chilled water temperature = 6.67C. \item DX Cooling Coils summarizes the Standard Rating (Net) Cooling Capacity, SEER, EER and IEER values at AHRI standard test. Currently, these values are only reported for coil type = \hyperref[coilcoolingdxsinglespeed]{Coil:Cooling:DX:SingleSpeed} and \hyperref[coilcoolingdxmultispeed]{Coil:Cooling:DX:MultiSpeeed} with condenser type = AirCooled. However, the EER value is not reported for the multi-speed DX cooling coil. There are two SEER values reported: \textit{SEER} and \textit{SEER Default}. The \textit{SEER} value is calculated using user specified Part Load Factor (PLF) curve used for energy performance calculation and the \textit{SEER Default} value is calculated using the AHRI Standard 210/240-2008 default PLF curve and cooling coefficient of degradation value of 0.25. - \item - DX Heating Coils summarizes the High Temperature Heating Standard (Net) Rating Capacity, Low Temperature Heating Standard (Net) Rating Capacity and Heating Seasonal Performance Factor (HSPF) values at AHRI standard test. Currently, these values are only reported for coil type = \hyperref[coilheatingdxsinglespeed]{Coil:Heating:DX:SingleSpeed}. +\item + DX Heating Coils summarizes the High Temperature Heating Standard (Net) Rating Capacity, Low Temperature Heating Standard (Net) Rating Capacity and Heating Seasonal Performance Factor (HSPF) values at AHRI standard test. Currently, these values are only reported for coil type = \hyperref[coilheatingdxsinglespeed]{Coil:Heating:DX:SingleSpeed}. Also included is the supplemental heat high shutoff temperature. +\item + Water-to-Air Heat Pumps at Rated Temperatures Report includes the type of coil, capacities, power, COP, rated temperatures, and design day used for sizing. \item Heating Coils includes the nominal capacity and efficiency for each heating coil. The capacity is calculated by calling the heating coil simulation routine at the rated inlet conditions: inlet air dry bulb temperature = 16.6C, inlet relative humidity = 50\%, inlet hot water temperature = 82.2C. \item - Fan includes the type of fan, the total efficiency, delta pressure, max flow rate, motor heat in air fraction, and end use. + Fan includes the type of fan, the total efficiency, delta pressure, max flow rate, rated electricity rate, power per flow, fan energy index, motor heat in air fraction, end use, design day for fan sizing peak and date and time, fan purpose, if the fan is autosized, the motor efficiency, fraction of motor heat to the zone and the name of the zone, airloop name. \item Pumps includes the type of pump, control type, head pressure, electric power, and motor efficiency for each pump. \item Service Water Heating includes the type of water heater, the storage volume, input, thermal efficiency, recovery efficiency, and energy factor. +\item + Chillers show the type, capacity, efficiency, IPLV, minimum part load ratio, fuel type, rating and reference temperatures and flow rates, plant loop name and branch, condenser loop name and branch, heat recovery plant loop and branch. +\item + Boilers show the type, reference and rated capacity and efficiency, the minimum part load ratio, fuel type, parasitics, plant loop name and branch. +\item + Cooling Towers and Fluid Coolers show the type, fluid type, range and approahc, design fan power, inlet web-bulb temperature, flow rate, leaving water setpoint temperature, and the name of the condenser loop and branch. +\item + PlantLoop or CondenserLoop show the type, if it provides heating or cooling, the maximum and minimum loop flow rate +\item + Air Terminals show the zone, minimum flow, minimum outdoor flow, supply heating and cooling setpoints, heating and cooling capacity, type, coil types, fan type and name, primary and secondary flow rate, minimum flow and minimum outdoor flow schedule names, and maximum flow during reheat. +\item + Air Heat Recovery shows the name, type, and effectivenesses, exhaust and outdoor air flow. + \end{itemize} \paragraph{HVAC Sizing Summary}\label{hvac-sizing-summary} @@ -207,13 +233,31 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar \item Economizer which includes the following columns for each \hyperref[controlleroutdoorair]{Controller:OutdoorAir} object: the high limit shutoff control, the minimum outdoor air flow, the maximum outdoor air flow, if the return air temperature has a control limit, if the return air has an enthalpy limit, the outdoor air temperature limit, and the outdoor air enthalpy limit. \item - Demand Controlled Ventilation table is for each \hyperref[controllermechanicalventilation]{Controller:MechanicalVentilation} object and shows the name, the nominal outdoor air per person and the nominal outdoor air per zone area. + Demand Controlled Ventilation table is for each \hyperref[controllermechanicalventilation]{Controller:MechanicalVentilation} object and shows the name, the nominal outdoor air per person, the nominal outdoor air per zone area, outdor air per zone, air change rate, outdoor air method, outdoor air schedule name, effectiveness in heating and cooling, air distribution effectiveness schedule name, and the type. \item Time Not Comfortable Based on Simple ASHRAE 55-2004 table shows how many hours that the space is not comfortable for each zone under the criteria of assuming winter clothes, summer clothes or both summer and winter clothes.~ See the \hyperref[people]{People} object for more information about this thermal comfort calculation. \item Time Setpoint is Not Met table shows how many hours the space is more than 0.2C from the setpoint during heating and during cooling.~ The last two columns indicate those hours that the setpoint is not met while the space is occupied. +\item + Thermostat Schedules show the thermostate name, the location, the control schedule, control type and name, heating and cooling schedule names. \end{itemize} +\paragraph{HVAC Topology}\label{hvac-topology} + +The HVAC Topology Report (key: HVACTopology) produces a report that describes the arrangement of componennts and includes the following tables: + +\begin{itemize} +\item + Air Loop Supply Side Component Arrangement shows the airloop name, splitter name, supply branch type and name, component type and name, sub-component type and name, sub-sub-component type and name, mixer name +\item + Air Loop Demand Side Component Arrangement shows the airloop name, supplly branch name and type, supply path component type and name, terminal unit type and name, zone name, return path component type and name +\item + Zone Equipment Component Arrangement shows the zone name, component type and name, sub-component type and name, sub-sub-component type and name +\item + Plant Loop Component Arrangement shows the loop type and name, side, splitter name, branch name, component type and name, mixer name +\end{itemize} + + \paragraph{Adaptive Comfort Summary}\label{adaptive-comfort-summary} The Adaptive Comfort Summary report (key: AdaptiveComfortSummary) produces a report tabulating the sum of occupied hours not meeting adaptive comfort acceptability limits for each relevant \hyperref[people]{People} object (\hyperref[people]{People} objects for which adaptive comfort calculations are requested). These acceptability limits include ASHRAE Std. 55 80\%, ASHRAE Std. 55 90\%, CEN-15251 Category I, CEN-15251 Category II, and CEN-15251 Category III. From e4ad2165a389a3d2ccae90998d8e64fe18055441 Mon Sep 17 00:00:00 2001 From: Richard Raustad Date: Sat, 29 Jun 2024 22:01:35 -0400 Subject: [PATCH 079/115] Relax restriction on calling GetFluidPropertiesData only once --- src/EnergyPlus/FluidProperties.cc | 4 ++-- src/EnergyPlus/FluidProperties.hh | 5 ++--- .../unit/HVACVariableRefrigerantFlow.unit.cc | 11 +++++++++-- tst/EnergyPlus/unit/PlantUtilities.unit.cc | 8 ++++++++ 4 files changed, 21 insertions(+), 7 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 3cd8b996ffc..c63f0b6fc95 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -157,8 +157,8 @@ namespace FluidProperties { // Array initializer only takes one argument. std::bind is used to convert the // actual initializer into a function of one argument. - if (state.dataFluidProps->GetFluidPropertiesData_called) return; - state.dataFluidProps->GetFluidPropertiesData_called = true; + state.dataFluidProps->NumOfRefrigerants = 0; + state.dataFluidProps->NumOfGlycols = 0; // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 5cf7f82a727..3cfe2d5111b 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -625,9 +625,8 @@ namespace FluidProperties { struct FluidPropertiesData : BaseGlobalStruct { - bool GetFluidPropertiesData_called = false; // Used to get the input once only - int NumOfRefrigerants = 0; // Total number of refrigerants input by user - int NumOfGlycols = 0; // Total number of glycols input by user + int NumOfRefrigerants = 0; // Total number of refrigerants input by user + int NumOfGlycols = 0; // Total number of glycols input by user bool DebugReportGlycols = false; bool DebugReportRefrigerants = false; int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index 2ad2ae4ea5f..b35f80f6438 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -2353,9 +2353,16 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) state->dataEnvrn->StdRhoAir = PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0); // Read in IDF - ProcessScheduleInput(*state); // read schedules - Curve::GetCurveInput(*state); // read curves + ProcessScheduleInput(*state); // read schedules + Curve::GetCurveInput(*state); // read curves + // test consecutive call to fluid properties getInput FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties + EXPECT_EQ(2, state->dataFluidProps->NumOfRefrigerants); + EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + + FluidProperties::GetFluidPropertiesData(*state); // should never happen but if it does it's safe + EXPECT_EQ(2, state->dataFluidProps->NumOfRefrigerants); + EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; diff --git a/tst/EnergyPlus/unit/PlantUtilities.unit.cc b/tst/EnergyPlus/unit/PlantUtilities.unit.cc index 8ac1aa0055b..985eab7d687 100644 --- a/tst/EnergyPlus/unit/PlantUtilities.unit.cc +++ b/tst/EnergyPlus/unit/PlantUtilities.unit.cc @@ -90,7 +90,15 @@ TEST_F(EnergyPlusFixture, PlantUtilities_RegisterPlantCompDesignFlowTest1) TEST_F(EnergyPlusFixture, TestRegulateCondenserCompFlowReqOp) { + // test consecutive call to fluid properties getInput FluidProperties::GetFluidPropertiesData(*state); + EXPECT_EQ(1, state->dataFluidProps->NumOfRefrigerants); + EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + + FluidProperties::GetFluidPropertiesData(*state); // should never happen but if it does it's safe + EXPECT_EQ(1, state->dataFluidProps->NumOfRefrigerants); + EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + // This test captures all code paths through the RegulateCondenserCompFlowReqOp function // We only need a single component to check here state->dataPlnt->PlantLoop.allocate(1); From d39287b7bc147dfe54ee7fae3986c7aaea7f902b Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Sun, 30 Jun 2024 11:51:07 -0400 Subject: [PATCH 080/115] corrected swapped argument for HSPF2 calc --- src/EnergyPlus/StandardRatings.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index 846600bf9ad..6eeb9160a3e 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -6668,8 +6668,8 @@ namespace StandardRatings { RatedCOP, RegionNum, MinOATCompressor, - OATempCompressorOnOffBlank, OATempCompressorOn, + OATempCompressorOnOffBlank, DefrostControl); StandardRatingsResult["NetHeatingCapRatedHighTemp_2023"] = NetHeatingCapRatedHighTemp_2023; From b2d498a396ce53f3c8221949f5f806681190ec4c Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Sun, 30 Jun 2024 11:53:03 -0400 Subject: [PATCH 081/115] corrected swapped argument for HSPF calc --- src/EnergyPlus/StandardRatings.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index 6eeb9160a3e..2ed8a6bd420 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -6646,8 +6646,8 @@ namespace StandardRatings { RatedCOP, RegionNum, MinOATCompressor, - OATempCompressorOnOffBlank, OATempCompressorOn, + OATempCompressorOnOffBlank, DefrostControl); StandardRatingsResult["NetHeatingCapRatedHighTemp"] = NetHeatingCapRatedHighTemp; From 5e55429eb98ab476b0d007ce8235d80565c3a2b8 Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Sun, 30 Jun 2024 14:15:54 -0400 Subject: [PATCH 082/115] OATempCompressorOff not assigned a value --- src/EnergyPlus/StandardRatings.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index 2ed8a6bd420..ee008bd4bc6 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -6266,6 +6266,9 @@ namespace StandardRatings { Real64 e_sum(0.0); Real64 rh_sum(0.0); + // The minimum temperature below which the compressor is turned off + OATempCompressorOff = MinOATCompressor; + // Equation 11.111 AHRI-2023 Real64 t_ob = 7.22; // temperature at which frosting influence on full stage performance begins 7.22 C (45 F) for (BinNum2023 = 0; BinNum2023 < 18; ++BinNum2023) { // NumOfOATempBins From 49f814a3eb07810caa447db85e920113dc4c8cdb Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Sun, 30 Jun 2024 18:56:27 -0400 Subject: [PATCH 083/115] modified unit test result based on the fix --- tst/EnergyPlus/unit/DXCoils.unit.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tst/EnergyPlus/unit/DXCoils.unit.cc b/tst/EnergyPlus/unit/DXCoils.unit.cc index 98d38f6f197..832e50d3340 100644 --- a/tst/EnergyPlus/unit/DXCoils.unit.cc +++ b/tst/EnergyPlus/unit/DXCoils.unit.cc @@ -4656,7 +4656,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput) Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000 ! , Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34415.4, 20666.4, 6.56, 4 - DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34697.2, 20948.1, 5.12, 4 + DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34697.2, 20948.1, 5.34, 4 )EIO"; EXPECT_TRUE(compare_eio_stream(htg_coil_eio_output, true)); } From e0c10d61616086b42adb5c257ffd5ecac55d7b2b Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 1 Jul 2024 14:03:51 -0500 Subject: [PATCH 084/115] Add new example summary tables to output details report --- .../media/air-demand-side-table-example.PNG | Bin 0 -> 90662 bytes .../media/air-heat-recovery-table-example.PNG | Bin 0 -> 12855 bytes .../media/air-supply-side-table-example.PNG | Bin 0 -> 40474 bytes .../media/air-terminal-table-example.PNG | Bin 0 -> 230625 bytes .../media/boiler-table-example.PNG | Bin 0 -> 28317 bytes .../media/chiller-table-example.PNG | Bin 0 -> 78530 bytes .../media/cooling-tower-table-example.PNG | Bin 0 -> 33030 bytes .../media/layers-table-example.PNG | Bin 0 -> 57740 bytes .../media/plant-loop-table-example.png | Bin 0 -> 80211 bytes .../media/plantloop-table-example.PNG | Bin 0 -> 7304 bytes .../thermostat-schedule-table-example.PNG | Bin 0 -> 265608 bytes .../media/zone-equipment-table-example.png | Bin 0 -> 63620 bytes .../src/output-files/eplustbl-lt-ext-gt.tex | 468 ++++++++++++++++++ 13 files changed, 468 insertions(+) create mode 100644 doc/output-details-and-examples/media/air-demand-side-table-example.PNG create mode 100644 doc/output-details-and-examples/media/air-heat-recovery-table-example.PNG create mode 100644 doc/output-details-and-examples/media/air-supply-side-table-example.PNG create mode 100644 doc/output-details-and-examples/media/air-terminal-table-example.PNG create mode 100644 doc/output-details-and-examples/media/boiler-table-example.PNG create mode 100644 doc/output-details-and-examples/media/chiller-table-example.PNG create mode 100644 doc/output-details-and-examples/media/cooling-tower-table-example.PNG create mode 100644 doc/output-details-and-examples/media/layers-table-example.PNG create mode 100644 doc/output-details-and-examples/media/plant-loop-table-example.png create mode 100644 doc/output-details-and-examples/media/plantloop-table-example.PNG create mode 100644 doc/output-details-and-examples/media/thermostat-schedule-table-example.PNG create mode 100644 doc/output-details-and-examples/media/zone-equipment-table-example.png diff --git a/doc/output-details-and-examples/media/air-demand-side-table-example.PNG b/doc/output-details-and-examples/media/air-demand-side-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..5c7c6e4bb57461d01544b7be66219753a1ce778f GIT binary patch literal 90662 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 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/air-heat-recovery-table-example.PNG b/doc/output-details-and-examples/media/air-heat-recovery-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..097d0b08dbbbeece9b24b6e2056f391e73863661 GIT binary patch literal 12855 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⋙)J{bVdduhTi5<707P@sXd4LI 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 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/boiler-table-example.PNG b/doc/output-details-and-examples/media/boiler-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..9d921cf4ea65b633aa540c77870e30ce41a1065f GIT binary patch literal 28317 zcmeFZcT|(xwg-x$prWGUmJT*Rq)C@vR6weL(joL7qVygW1(7DbgGdu;h7vjvDFGsc z9w0!J4gmv!5J*UPaqn~QJ=cBix$mFX#(0bYA!~fex7KWHe!uyfEBcYX=D9N*XXxnY z&OOw+Z$w9T>MHI3j#CV@zn2S)(`YZpe2g^J>8b{~)@W}|xTxu=(a}K?m=5hu(%zqb zs%7p&M|ZyS*Y7bn=%XVYotMPJ`)ZE^Z8me;{0NOTB?@mn;)=7s1UlrN+B-449Bqq+ zuW2n>`&>Ve82O%Far?6BqwEj2)`KR#u3tHQ{PowE>!-daQ%SUM|8GBm7tde)Zv%96 zUl32}j{P=f6G?ySx1lWwF4fsiJNzYTqNy8HaMAv&?nV<&za3uO1B z`+?lqT&RXo*Gu3beRuoFH`0>cKe^bW5-SeZC1Cz80=pBZCL?M#AC0Jygc83U&$BiO!?>Uj#AWh6P}u050_Ne zoo~2NfgJOeXS^`Si`@Ys-wE9~+PEhia3HrNPLT2cO@?1G&oW>Ac=J4~qjr0+>v!bN zg5FXsBYO`0DZ-Xo|D&HV!Hd@-_jO5fV?>p;JL*cl7qEYm=9d5oq5#|akC)yTt^#hu z65q=`-P%j6_2gCk$avQM;=u~xPKP(08ke?~FiiSI1mkZqGPV6lr*2CDo(LL+DRJ56 zqvfA}rdAj$efd6q?H#zeqlNjm50q}N(Vwb5VtBPDd)+LO@xmEtgX*)tU9%s&eEw=9 z4ETOABqY43@`&WZkwt&HjsDd9g$PnD6B>5xnsNir-Cn}qtm-@Y5#xmk`eWhlG6&d# zh^#KP7X(@UuHC(DBBpsGYkZ=~PYJ(rupg+{MF~FjyJ5ATT#>!{+g#{2BL1e({~PS| z|HUr!|HRbBj=ee}9#MIt?_W>Ux_Rkey%@<-R#c7zOV3IT&@Lu}kHr4E$|!l>@oS4d zDKnaSGdFdJW9|HD?qqj$rXtBp@;9tS3i=iDli=On0y9h`mciqd z9o(w$M`}z@8CK6$F=Q#84?S(l829zm?lHO~L*2iEfNqE451XOde0u9r35Gt<3`wLku6q_I7-e46-@`l?pd<0<2i_~W7DImhH9%3ts& z&;!1Xs}azq`NhTlkXx)NklktST?vRrc-^ zf9m|pxMPf||1yqNfY{=LJ;_b2bt`!bl)>+vwQzbcQ=uscE93;J&H|K*h>ws}v* zRt@el)iDInao;;B@`e4qWFvs$kRJHZ`y<7O_Qr8j7cG2ez(|G2Qtqa5MnKtJy^Ku^{hkhgyaej;;X7QzZ6- zo25`aQl_wo&t`ruCD)gHN}J;RZNG2R3``Z0nOHo)Zn9edcmdUxFiMaz2RP^G{8@-qZC~F)|I5Rw+v* zP|s5~g$X5$EN%kgG70qlW(wT+3EPn5jHVz92zqY!%OZzht1%HNzfu>Oo`dCJM^ zvMw1^uzWoGef|fpN2@3EownD;QfsPL_$sBDg8XjS9(|nw?v7f{#KyeQPR&M;}QW$wkp@|pzq5d9I{rSwSoYbAO< zwz}lYG2t2nf(+1J#bdTlJcUf&-cIn@ymIDNdu@0haE$tGhYJZGZm3k5qY{6 zV)A@YNgaO2ZNYYeJFl;iIgmQkk4NY?fmd9{n7Lsu$Pwz0Dy%ey35#YMy3t3 z{ThZ1zU(|)Ei46Qqd;PNOT}8@Pp9YWA+9CS_u{Vx$1Gw9=M@*}zQ$0Lm7lBXqPwq& zZ+7eT4eW(%ON>pOU>C#0*;n!%41g@<7mK_WmEGZ0ECBVR5T|frs{(qO7XukcAaW8L zI$|Oy7+-PCa!y2y14Z)ee<)4IK*;IvCuxp!+$MAdy1y__aYF}Lg--L7Yi^zUrMLVO ze+xV-gi>o=!5I9{}C57x^$4yzpLR2OsHecq2n|Qo8t%@K#ylIt;l%ibm zJRsxtEF=nyZIY|s^_x&;P~n7y7SDXQ9H=z9pw4nfEKF<@svKY8P*^i|4J)IJc;%9< zH}Nf?jh+*XYIp0&ns`Jg-UDeNd??|@M0IL_M?}$NVLtAjt|joHuR|6l--DWE!dnJq zZ$X7zI|>1JUQ5PKP|u+_@=Z9sgAdV7X>ndXMZo-Km$1u*gy@j9V9%I|3iqsFnFcg* z+&$SVq+oxp4K-CHtigsr(2?~&!rNb(;cW1+Hfb1ej$3S)|f;6?fh(RBIj z4E75PEzxpkKvu6j^g`<)d>`Ozt2UyTcr0EQ4gltSR=xu?3ET@Fn_NhD3-elFT;PtU z`xmz1((=@SRbAql_yf`BlMgcd4f#di_tuQ4n|-^=`g!cOzVJQak)qd)W~Ju6g2*C# z+Jl?5lTX%r%^N&fQ&vKG*^K7K=f-(9N5>=gefltAG7_#j2jKdQ)T*`avThVp2Y*9{ zm^%?tg59DU^M-!|XM=4|F_lTO|CA)B=f+`i1;U>Cfc4+@*X%EFlZqK3t zhD8>0d)rAbn_49KRcxk&k2PEElq%|&cPG?e>yOuM`LaoVn9d1|g=t$&URr7j*z(3ju6nO? z3-t@#8M*D$c6!XGq04k0`kj#!I0bU=Gef#t(f!?l7wVRWW+ z*s(})Crl;BCmCT5EtT=$SI+k_d%!m;9t!taI1lAbvq=sn(1(*|Xz5RNi-`{CLKjQX z=@f{x2E+D`7U>{?cw+Im_An~;eA>3{?#H@|;IqW?!TGi%S?oZ(NCClD&-GKb=IWhk zQK?FEbcs`5k}565)BNGT~1}_}!QNHFq41Y`Vl_ zbdJ@#UPkO}#CuMQ-U>p!E@WSyH_~#xsFUizn#wX*TL`_M6z31=7uL@_S(O3z@LJ@n zd}ygnR>Z`SWoism23}g*T4|zry(OFU&NITQ>{e1n8xv6GpHItr}DJ zK8SU_<@BfZ1Z7F+ts0R}%*A$PKL>Z#ZGx&MvtsTz{XtdCFRzTm1v3Uy{dEC?3pbZ7 zLtVn2^t%}e-&Lw66w7c67gto-Sif;ATODaHz_n66LsP-}%7%gy3$bq1l($xS!Ti(1 zcf0ylY(^dA+?oY--jj588??KrB_cK9rJD?GZd~{Ts@0ovxHhDA=36##$zr%9r11x3 zYBP$q^Xi272`4D09f3kWkdVrppB*Y`VL=%F`e!NhTcx}+kS(s;N@FZfE0681{yc@6 z5$8Ivzo>Yl#p39Jyi;j=A9Tr5F27&q4Kt>)PvKdsm`;8=b)4eq>iekrfKt_;hMTpa z`WnQ_idFY7tUlEmtcE{eV;oRaO*j{DHtI6sA+ebuWe-8l-7EFJqF_%^$`1~7n6eGy zTx-oXn$ZPv?Kh3apIYGldp=83wbU|h8te>Bz7c#}18_hpjZ zsK1(Z#?R@3z8K9W?#&Nrwfp>`VY7&yje?&U|)}zWq>v#SrERdpSvN=%DZdI zl*QoPXh2?a!J9R01B+IRkrd=1xSkgu%DH?gcZfxIh0yky< z4k?=*P$eq#K}EfNh6k5*bB0&ykd_+tV_qm$=^Y7plfCB@m06W60Ov@RYqiho)e=dN zY7mpS9y*D#xfVE-A6Gq(v|)cSqVg$32A;PU!aq4g+kXKo=5|N7c=%Hi@U^oWdVqeC zlI2QXJ~XPSL{jCJA^{PgBt1C8@R_3;bL+Q^$TK4g&k)2 zsl9tFh)V}e>j^ofDK{wJ0;A~vRpv4!TC(^$aacViO2ow>vB#XvC`SF<=6q7WN)2e# zKhEl#N3{Q9O+_2YrEN0hLX1|YOT$JzksH9jP6)uEw5wZ->U$CI#m_ABP2a6Btr z`%7B-Y`$@7toxJSv0~w$AG>)E8WPdoH7fPUG%#ge^z4$v*zu8kk{BG_%?G;Jr<~0S zZt!eKso@~o%VFzhl-us2CU2~#Fzp&6n}MgzFwxzDl$PU}r1<9_*!UGSp|>((-$QE!H=$2pQO)B*aW+aC!*UxWl#` zK7mCP;K!!Y9_7iozC(PDsXS)N`O+7&Ki*<8IURaf74W{idnBP8qoXqBpGuCIdxfd( z(WIE{x-PtKb}kF@1a}2bcsOiM26v_cI7i=dw^4BKnj-`cmdTu{IDnX%=4P>OT4N!DW?L<02?`S2pnM1qdOW)LVLYodNLLb9zB%SFy zG^F+CnWbS1)o14VTD02K$a7!+{&Dp+kR-Vy+VN{kf^(Isr0D8wW$Xk zOE$m;bOS#~+XE9w+9tPupC|}p-+a8}HO0z4Yv~#`QZ&LkH%aCNDf;)k4QnTbBO6`u zSu!S5jSglP5wesE524xOg}wf3_*Rd^r)_N??;dfxQa){(P|wMZAwdZVn&aBRt|A^H zooQmB6{Pj;?O3Oltg#ED8XGZg?yWKu_F8QI4GN?P8-K(B0JT?5LNNTu>ZRs@0cZ=y zcubHNxZa-+BOO%FaMH?FN`9Z4VO4m{Fld3)6$_oSxNe;8%-os^f({8?croF{Bjf zl+;4sO#>H1Sf$HS=LLsyrKz-o{jC~)<81f*N>A>dO#5w9%W(d^!bTThbn_PJN6cN{ zP+5!Zu%Ype1pwA>is)XELG=14NtH=iYFbxt(h>3CzUQ{l7*rA224QoZb~m9CH+FrfNA4@p3lw8VGHQ8Z?=hG|gnQ65 zU8V2C1CTHy=aYOeGe%bPg&doX^xRs&!?+jWGvr_sSR<~HM@8|!@SiPt62M})uQcmj zI=C;8VRywq0PBK^LYQt*Cl5c~_t@f4!{+sl9N!9xVO-rWzgE%_uJv2e1jgT1n#y*!h!_nf>rKdbeysfTtDJr%G zb7If8&zY`-NUc{Sqy*qdmRIAg?rqE5N)SFu9*di~T*^gmA8$M>zOjBMEj0W3lqe1VlUGm%0TmE0%yr#M$ec8 z6|eDvD|sC?S1NQd5gC8alKO_fI-L1QZN<5@u!~;(AQ5hLhP~5ln5Ta2nuVJrEuM03 zVPHkU#}GMCs6ThDQb0M1TifM1pNmoKIYY>f*8i`ZBlInWX5qO@^q$|^A`q6n{pj6RZYdijTn*91LY@NjrzZ*FINw@y9G&w11%XP?u${?G?^FGNos z{OWIT@pcXW=CZogz6r0oli_SQaV$=`K2X$X0EFNjMr2=E=(Z2(ZO9s(W|b%cRqxJ1 zo$~*~wkw@_2daAm&+#caoM)`S-hP%5Nk(*ThFP}1RZEqcsI|5v&dM*Ayw_}mdC6#a zvm=5Ni0|L1^!s!Aq^i^d<-pqoTGJ}*_LJj+S%z-j!heLVx1%hgH#l|t<0NaV9K2=? zRHT5eQdMjz>}UZFW#JVTs@9Tpe5L2X$dC6KL!?K0hF#x$?z7*PBgFj^Ca&oq5F+G# z-1CUqBrB(nT3@U^_`Fr{H!zzPL+aj%!0f1@iuvm?8e*Z06QCT`&~_?J)0q0)%f{{A z{!vs#b$zvs4(Dmh|8xZkAu(0PVD8a3kE^$xQ(7r;?R)JaDoYIu&7N94ik3u|byrsz zPI^J-Ztt&32ez|ZdMMwffo8*gw3o68+K5_Z$U$52)R5WN*1M&bcvaW2Vx$gW!;az*k`aE%BCwqxWBWSd(Az`J(dJDA4 zl!*dWa}y;0ilZ(Q623ft+{ntuX7$U*6EpxJ7!izD@Y}eXVivOr44hlkqX&I&3Dfdf)mYLzVaeU ziu2J9%}OrE!2L>})pxo6i1DqA6~EZ&kmn-u^uyt6yE*x^N*Ed&oNU*rd~AW!f4EhW z3U38{;K$v;aaSie`sTIn8KQ0Bww5+;#jyyvB?BTRzZ?OMu;8%sx1D`A3{S^)M>KKN{H8@Zav~vS}N=#UwF&$nAdn9>McWM zhxy{h-AQghideLp>#^lt`C$^`S+Bdq`~bGbq>_4lbt53Tjt^rf z9qBhe!X9dqOt5a{H`s|T&TXnRz(z?pPt?3s>AxPLKeu15JADb^F~{oH&e`6Xwn7na zOGAd7IR8GDNvKa@Af#5re!~}~Iicvb@hM|_Z#!_zn@WTq*;K8xy2llzz^rrz{rU|u zp3Qbe4pTyLB3*Ia`VByKr$V%Bfudo1znJ~#5lQ99qm2h)82;8`y>5IFJEeWLMKqsV zXT7Q6eKDyj^suFmyap+n8y}QkS`9x~wuCp{LfQAbCEYS3dvNKmg0 zHPEeok4M>Yx4!u*w)|3Mhg%VISRt;4Zn#&{ssW|3{l|Yu)44Ck`*vE&Nw~A2lojZR zU=%)QsrtYL#wixL)VSD+WH<~`X2{+q??1`%T|U*3-FfhnhYj;N25;k51aBoW4uO$J zjzf$&`YYMYRUQ8vBt+Xzb`Gm|@T?*M+PF?&@G*n}8;uOnc*Z;?I8jXO&^)YWEtIAG zW=X-x3;}LWLyp_HF6W)eY}7NlW1&W8g9&smSs4M}iLMf{Kce=+Xxs0W-tPIUm-QrY zZ4wmXp#ekKm$j#KKSus}BNBKdqiK&Csr-5{CU(#DShSk8b;g~Qk7+%EOVZhQ!#D~JUwx3LxvGI}?UUOTaS ztkh^lRq)xVA8-G8ezXeeVR2D{>`|efm~Hp#2{^p-u-_X8KrXgk1GtFOW>!}88uets z5S8#A-DnHZl8TM^d0mtVq7w6`@$bEpWpfNI17m}xJWo9 zu1iPQOy=`fzZ4H~1_wpR0m?a?Mh`SXAL`y?`pif<{|)S3U?s%aLVg z{lrNBcxL?(eo_z4uUz6G4RxZdd6RwQ|8Z~m=eBbfa`?qSV8Z890cCVg*X$DYIDd00j8Xf_4QrZl;yw&1;ahh`IpY*XiN^T@S-+_C4_E2j!c-0S4u5fWPM`aoxDvI0RI_*xsF z*Fn1(hm-LGkx#)WDd8@v>YolVsT0I}TO=4IEGJ6y24SzWx3k}2J5ChlUqYu1rQuyD zZ7K*!e&^-jLl@ycYuOw2SUUCSlQbC%|4SJ|Ww8DBsW#v7RS#(edQ>NwHKz?cZf%i6og4<$^NCLjNN&AHYFJv=na8_2RiXgiH{ znhMrOUD)tr`jb`AGO76dLR0`7jGunTX8-oTyt|AnR+*mh!grqkl;(F~+B8%c|6w1` z=zd7vLA^k}{JjFpMA}LJdhEn=(O;7J^$8A|T_TVDS?jl^Rrp02{$A`y0^X7cE!Coq znE;k=$4=}Qd<57HsBa+WhiF>-ezV`%Xqr ztaUR)ztI=$so($&;eb^kV zURY$P&U^FH!x9b_#eJ4v#Hl~26aPO;<^Nii%8ztz)xe`b8Z`wDxUMvZt&D1>qG&V} zBzQwQo2TG@K9TnDbJ@mq-8DI^tG216VI@DQJ56YlL}RG15a;rEk9IPc54&B z#0}>5^~-q8iTcCA3#5)f(fb4(N;~Cm~Bl_n@jgK^mE(Vu|+b zhq?pnr&+Ynb5!bnNXelJGC}s)Kw35W5*h*wC`ZjOp#0(aoibNQ!KdA%Y_dod?XCL@ zu^?n`m5h78Uz}&d!dDj?77uIc-St@m2qXnIJ;rMwarA*$paP}L6~R@=J++^%PEuXr zUHDdZMsdP|nwI4CxL)suytREDkFR?#Fx8=s|1-mBMbpjqGfz3{^1Un?xUPkL>d#G; z^q7KtoFi?zha_vJI!ws(9_85}pHMjt93J)JV(jL!!rPn(H1;JCLm?cbFp!x7W{eL} z4wkqy|Jc9~+eo_*;myf<2e5Mv>7V7211(+M1PI5~$uxwCzda4Z%U*Si3Q-pve0)O& zuw$c)v)j6x{vc|N44JFXfzGhmPTM9vl!gZL?#hYOQe z2!b4j=<$5B$DF#k$xEgAE$!!l=Am3@KKvx!L9PVAiq581T}HP6v37(@Yi=bZO#p6f zV)UDt<{#y8e{jcGps}w)Dl*Ne?)Q+?cHY|*a`2_po%$?yhiHWZZ;ByVJ;ly9d76)K z2`lWBKvpBWTuV9nnCiEYFd3MH7~M0?2VtKOA-MchVktK-#LL0ub6D*(9TVUG%oIBa z;t;{UnEPsCo^H~xk>$g;yeS+%UjM{e(<+~3Y0^8le&dfes43VhuK~(5FaM#np{>dc zrPoF)t+|rNZDo?vPCbwPB&95SRC`%)bAJ;5wK_cWDuT6J`U2GN zd)klUEK@I3LMwswhjC!?*U4h^b5<}dAF2gzdm>SheyvgagWZc|FkMvwe?%A(6b7x7# z-&YH=B9I*eVKi1ue({;?(mjYyH3%Liu}gU5Q_$|5JZHtJm>*iWPS`-ANHX_H$olrJ zXyr#i$+M8TcFb+zlz$V*R%n4t)EUKdV~%9qD?8n#=af#U{W&uA)OvWn0waU%o#Vj0 z4WRq+QJPv8K3zs`==n^|@-|0~>-&*J7qQX8O9^3*`q!&|-~jYcrzHZpmUx*PEEU`k zs9d+GI4hycZQa5&Et}Zp4yskyY`T?E|Bz*pA?0#Bo|%p8H${^&i=#C*&AzNL001gKW);U2Pw zvM8hpxP~!`THRSpF6hWpvA+nJqu#e)#TG1c0T{{StCh7U>q?Z3NZ#h(qBYC_!-Ll8FJ%Rfw4K~-SDqIR~#)3Ni9>mnPr{|?_ZlUOe zsK;LIV;ZT{X^tb;Fv6djs3~Qt#(k}~ap_V1NHhZPPIxg|1h@i4p`w&FLz~atpnG2V z+)ReD+eVfkgMdP4pt6*1S|Shv1ob&+P8^(WK~Odol@wm)(zL?%PW&bnjDcku>h8BO zUU++IrYN}J%xIC<=fsYJQ!|@SG%wR{ytkgdb1C!Y8;k6Vo;S{vuBenzoOsPNKiU18K@@pT5WjMma$^!Homb4{H4n0K5 zuSCkoL2)4P`-KJHx8l}!faqqxrhETohdUH5`zN*LxZ!P01IgC~)jAaFPJyxyo!Zfv z3e{~j*|K16a)^W4kJ#=nyT?wTtIrqKnB8jnANj+B$Wd2N+*3XG%<|gs717t-t@9cd zrW>0AXHkEM_=i08&lwR2YbrUHkl}e^v+GCIUFy7S0 zesIK{g;#b6_%47G%*|0QH@YO=4iTTwh{Y0vy+ zgl@L~8HSDzXFe%&Vv~+wO>S34%onW| zj2Z0PV&;}h7er*QG)!OLq-Jnk62fzER6^5A=YwZ-*NjNl2~PV*Huo6XQ#l4wB+&iI zD&*$%A9bd?14cH(-8o)}RA=1-ltnA_ghKX8(I${m+p6+ye~VODr!rper($o@E*I_M zPSvF10%J*G*$!S>aaSbn0YZRgrwCKqo?zg__XEfDPo`)L*wl<+dZW&KB%V8J%%EN5 ze+gYd>wxBejscr`4!;RiGG?8OI&u z{%GNfL-`APo$7NM4HrSepak3-Oq$FUcJzb%!AqNNS&Ms7A3d<)5u-d$G`2VMR+u*T z0qmsa@+Pg12JtKJ0tPiR9Y^n^dAYiEcm!Zr)0SD_*uONF&qI+Eggz9-eT$#Y?(~?_F6)DCG$D0g7!q`?* zd8TX@<|7v~cUIJErikTEms!Gb$6l?yn8mf;`Wb9Z1>aj2MmO15 zhmmBMw3Q~}rA}F%l;$*?vjt*jT>|)HTDA>1T=l0)a;F$vo;GfZy!dcBi<`4K5E=+1 z0tbP$^u9g+c(icXc$*PA3~PS4-Co~O=2LUHUke+C4Np97C)m{$^6u9}7VEXi_be@v zE0?_wpo#!`rP&g!M*ikq#A;&_c3Y}q=YaGPN}S1kqb$q5xHvwY*?;+<;ipR|m~TcI z07QlFPz)(^*>?${xoeYYQX-pYl=rx%ASy}I-zPC71vHMZ^LC;d=MrU$X`IojD_4;T z-g(uHvsvHmez&MI#Z1jOlqw5#D;=(EC9;z}xGDuXys(#-`sEwQt9Qe(nhU1Gt^#~4 z3SCM7B%h4usu#CUZr~NdM2fgE%(-IV06)aR^)?n_sqQr&rf-2HPyop)RpHt3(QZpM z^x~Th*XkezOU~!bk}sz40H`yZxoYW3xQ<>EY9Bs0>v8bhn{ng4Jk?-abEpNBO2R*0Z2>Z}~tw+gi;qNUv1g z!#B5-TjYx>iI|X$L8;A#J~v(RH|3*AwXu|ya7QzBSP3BAz8`lNAa=FOkzqwQ-+*SA zrNc$(M(yF~#Wm;z7z{pCdeTmaK_zrV_LNpq$_(P51cyz@N*lfPRa*qSjdc*}l`Bq| zvl%Vhy;pcH+q)ey;bg6m|H7+f_ThtvdYE%RW2hcslWRMHaEM1Oh`S~9DBUtLbGx+| zRvf3V%L6yEHbH7Usp?A!o7jUKt*};X+T^8fD_$d;WgAm|#vPeYv|~vN#wpN{*H@0( zO#l$fD@No2!Ml5wV(p=SzzBug9)Zj|45MHOES-&m0F95}K-XQqpR+#r#JT5jUtxbn z86esIN7A+QCU;*zkn6el8y*mMJ#1Yu#rTO~izUu4A5-jL&mn$J!jN+rT~xjj2%9a6 zoi?^O<4|^#y>BwazP}N|?6s0F2GU7hGylWVbbgXOE9km(kE}yeMT;xh=jqubG9o}N z0>7fy#+bE-UX&^cbIu1>?4h@7fB}K)j5tA)>A;Cv7_FP^7o0(Z^}dAn?7UKJa$mmb zbiGd8bn3nFp3dUwRPwVY{Bt4LT5#44y{&I2qzy#TeecOGN?aS&V<9J(!x-@^20Pa- zk-@_#^60K*=8(em9p7X@-aDLMV=aQGCH%+oX|-opiMSEFy)}XO2l?n*?uF9}=C>;zAEbv5{}?wI!|31PgGVTHu6E$tpMO;DnfeZ`c#h z69|ktfoBA^WF+s1W-B`%gU-5c^-nle5b=bDmD(9GPJXA307~OeuqUe3e^zKJwSUZS z`J_-{8Y5ahO~UbqQv{zwsBx$Z)`nsnmXi#`01{TbG0>oBd5?$D#AS!`55v+ny_CwXQ9{v} z;th=8k9IbX;Eg4GDevH{9HXeq0B@-tM( zmKCBcr>DIn7ZbohTl|CFHrS+D5O^0ygufY1A2S?67|-}3F2t?_E^t^S7jAzs`L%F6 zg)0ef7VLLs-}&OOhs5=a4CiYllq=q$kY}A58@c`MP}FRAp9QhkU!e+${$;Q)KlMZSLIigUrY+ype> zu9IuOq3ze1V*3Y)+UqBd^~ieGf8o07LOB@tJMQ<;4^Vc>e%j}~( z{4c`OX6MouTdA5&MMsd_%|u|IQ~Z_pJ}rlOOZ~vfxTu zrgW~W4sd_y)x_IE>-4+K*n#1jl*w0vUmS2DPlb;1@KC8K9@RIC;*y7vhAIk}J8SKA zeX*U(;cn?{mX<0j5_n?ft&;axv~c;mD!7D`<(XJe#x*xr?@$dW9w+!)=*zip9m+@AiScqJz6HpdkGg8KNg;RG8k2%*BxIh@?ntZvJ2>|zS25(kFs5=Mm|F` zoXDTBn)om;QYYE3j_~xY$k+Io@KC`ZAbT>w<86E^TSK8@9RvKL!=ZeS#)9g_U3sF- zYAogpXk1*p^6=`_5(D;lOHE|bN3xBKFN5-*@pA=%9w`FTUAwSQ{;`vq zv%WjWXvbBI{DjwgJkXCz*w<}xMli1i=tfiQH>Lv~If|g5H^6{(l7dq9~Lvg>PO_W+StmgOnIF&?06FeV!aE^0D|&vNiC1}Y1#85 zwLy7za_U}>O;6|FU#s~5@|`QL=!WqXx34e8r5vtJ3kcXx%ZyfcQuhuw$Ts8Kd;5W7 z554*up`bAR2DyfA-FP4$E%gAXtuhOE`NH4ydys3!lSW)h0XNFptNb5W;4cr1<#+Gn z?FXzvO#V#&kDR$2fx!;&m;rv1^K+;~OqqkdMRs<^9{GX=H0zd+wh-o{puvcLp4>Yn z`G{Ydh&YU{B)_iWU)s5L@XUl~bp#g$FAUFiYDv!!?#bp-03o+3Ir3vlKH=nty_}5M z66|>19Uam7mfs%iSSCp`B6@+Xo^v#khQ?mI-e6eS6>? z>YFFFZ3uUS#palHm2+4saH#P<<;7B)4Fj?- zWlxqjv@((SyIoLt>`X;E_#chFHU!k?EELL#<<`BTVDUtTrF#bSxH@ zgv1by&C{M77kP*nDPb7y?Tzi;PPO6(x5XuE9I zyp!eWZVMjjvfdENPRHjt+!Gzem_49PUmiQ}rkjDCGZQ%=dF(9}nAKJ^x=C?#zVp>V9!yzPbo76x+u8@oyJU z;UP^clNo?joL5_>Vuu-(FSs;UlSkDRjn@A#4TzCTc6t48j}=&rK0Bep+V5Ndqq5z} ze(zTKY^%B^yYpoHxu&z=h)ZE#!dAIdw|a79O$H`w7by`>s~52wm?$*F3Y?(MtvdPk zBt%Jvk4jaeQ7>NJd&`;2_>Xf0wnWa#V%pM!?P!ORH12(NYB<0bp@Z0?NTUklxmQ;^ zPyUQiR5s<+cG_n-S~!0-aI-%7<9-fdO*ik4e}BY+fP~pmMeKQc8i&E&ChD6-L>{Eg+96GcLrIW;R$m&1=P@T#T$q-L_DH}cs&8NbhAyDC#Ts) z?)m%ai^j(KWu|-zf?0jFU;pj#5xe(u2Ed5DlERs~3XjML2}BmQCeICcix`4Ur3IXb z2GP0UaBfx|JoBn>*P;E;^0N(W~ap%2fX{@0OFw&%Ya_ zt%TF7XQ)a!VM7n3KrZS$>j0ateOH3)4fAb0&tJVOwq#>n&80f&1hyc ze`eRy_cSL}+=F=1$b0YD#<3ITN5)*LpB=(tVc>U@G_V-zBZT<}Ij{Y7HO&G}6M3Yo zldD@Bvsv95t7MmUisnTWVK&6|I2Kmq&m0tw|0-E^8o0e)*}D>)e5>#O#5}EzDo}{5 zdDq;>bLH9jKkWfFjE{*7GJ)@z8=3P}o_}6^HbGbjhP8O*_q#HS)G=PT?o{#VaKY?d zp7};!khOv{4MYv0P#6dPbE2(fm>@fUo8Ckv8b^iJL>2TfyTJq6sfcN{Md)D4Ow&rS zl0`CW=^;qQPVW+QHt=UUOXmM>m-5(rx3))>fM9G=5ciO^iipR%;5MXKq02pHnjc+D zINfqFAD(KnLxewMH}(dq0DltCpGs+a<;;bfOW2#(JyJwLDjV*`w@mSmi!0=lfPa9c;&R8N@}`q=Ks;&c}F$5wQ1jT@POw~6$?d* z4MYT_7(hx?lp;+LLS=4sDHG-B6^>uS zFHZinx2adjdktSY3h0QwU&2DLj#5G*kF+sZLl80iE?Je)ynAB%5+_YkS@A6qZqoFh z<*@RHa@&7%Gn@aVuzp_y_x(@t3i`u;GMy)`1*XZQ66X{W#n-pSb!=Ef1iSGe+ebk$ z2=#4=Qt-95J4JYxOb<#5wtq98QoE!FU1cC`VM)*PeQ+Cvp43j%Oo5&&qwc&@OzV2| zLzs3JSd1{)!slkDle?~5#s_!g=GC8Z6hj5bC&*~{5-e`3qv+17)n7<0pulqhcTz^= z4N6R1nk+M@evpgdEpnTkT}9JT@*1y1J$sGuMHAJZNb6br&w&kLwq#GLZ;^|K@6@rs zXUP=yQkUG3QG4PZpubPoWhTljmADA66H;}VkRV5t;9n3yQ7QeFmQT#W&fpwWwNrVW zlVJFQ=>Ti5dB%w~lvAlc1Y;g%!(%Ag6b6%qZSfsVBVucFUl(yFO1qh93ljZR1iLSd z11>HoT!ZupSpr`Bhn01j>)j5IYku`$rzqAFQq(wtdbQe_cvQKbPn64D%lM*Gt8FTA z$FjL4<<_m~%}Vx=c`afqo9tmr8{f$umE@^0NWkARsv0mIcEw#F1FjG` zUr%rOs)}7eisSdY@0l;bSpi`VdVP58#*qsC9W%!&znn}mc&_79b66vnp79on7vYXrY^g)H?^zqAQ;VsNXznsmIK$w>f?95o%C4}o_GHHo& z0Zv9HI6&xh*_QZo<<0#cjw51kg9Fc->xv)_H*YJY8}BY&e)>kMZ+3FfbJY+PY9-`) z?iJF1-y0O9*hLBx3*?B4nDd=$5&2t=U*sf}OR#+(ygF(&S!cH9J7%sn3a6=R=W9I) zBqMT1d~3oy&`yp?wZg*X#m4E@Dh?5gw2m5DR>9HrMBFw3?th zm)se}vG|Cl!n`9G{C0(owXV1e!^c9Z!=@5;$DCwPS+&xLPRDO&JG7c-E-(YKj`2yV zT*~NH{)D-@tuua|&T4@v|Ls{sjCiP;-d{V!32vm^ODEKoysb=W_`LXl=5izhh!#*i zbN!5uV1<*T*^KMOVmAmWTHjhUE|GopZ4s65XLdA^cboo27nQ?@E>~1hs(yp5X4^&K zUSyoxuH)2zq8k-El8g zD62m`8!Pmv-vdGFZ{mcjHvn(C|DI1A&>)XtJXQHq?J8=Fw}$C#1#5+2I&4mWE{s=x zB$GZ>)~EN%OzbDwMU)t_?Pv)1#juX5r%s)KjRaWgk|tu{akY*WmQ6HO$-~(Y_%|BA zq-)#~K|6NtXJj zFmJofeS7jY`B+k=cTTZm6&o&@dcaUha`~A3(sAy-^>?1^FF|Gc>9_%j%TY8pZ!@oo zFB3Dbr|Z2_yD)E!J9nsiZ3n-Q6$*;Pc(N)Z|Z%^4O~~4UTdeG5w0- z1;B{9`RFILfr3hAs)gB~P33|nP9nv;W@e1vCmQGV>(|#~Q;;=RMA<8p=lA(s)F8UB zK27upzC5%x_r1?S?jUWdWJ*{zIx)UuyBr<-K_)M@b&aGl7<4wz7R=9EsuBX=I;2vs z4F#(VXxc->B&>PIv^RR<*j=68Ku70|K8o)NEE~apY?v5s#S>y8(tP>GtW6T{oiqFX zu^EJUa^03pbj_}j`6aD`GjY0W{$_a4Qa$}@S21rC&IECTMH%Pc%IZUN_920O%~LHj zBFVIt`HWNon#f*4Ycnyd6-_Whcz6!#m;`*{_F}c8N15FEss;!X>!WGwL?4Wo7g>9ITACO#ov_&yFC%6>f6pTu)*Kq+ zZe}(c3U%e>TYxVr?u;rbf}W>wYCQv>7N4_Axi@rghJ;eMAma-MZ6jD@3@^-`+tx(oMb$=DW98Uy$jKFOs)F`$1ni zw0_;npvs->-73$gLdcW&P^hC>SV!YAhwYFVg}jcfERDUr6}pI-c!>yE*Y?$-jVVYE zPi#a{{!yf36FRdSri892H5^IO`<3?9zB)Q=)T zm0C&ycda{qI#2d80pA!l43KH%Y}zGLOD6_M3T&UpXkNL9fS1lzGWg z!KQ12f$z{;ji<4nw5%{lL7XFk2a^+^AuIl1G(}YuKHn z4XvSv0}*2ut0~X#7_0rFCl>^zzPhkJ)%&g;0BC|~f>`ZL+YNRp&3jOS7Ot4|`F3*_ zx$O3(oY3&N8Y=W)XF?eQ=*%u5MvgPn$!WANbsZd9F*o|vkc%j;4%I&I z8B!Rp4`et<-p$R#X2klXaH~H^_ieoFc-pOz2jYXd&@9D?vhJys~0whH7!fJ^T$^EwHY7=_SFstQl|y$lE&z zz-|Ko*m<=gsPksrBIu zB9l0bl;sUCyqNHP;bu3VcwA_+*{`3o@y^$?InL8AqCSsFz&gN+klfq1sg=RDIL1-} zQkHtN8cL)@Ek!=+Z_zy00=!{O+`5UNS81&&Z{;5n+SciEVJ_ajO7;8}IvkB0s{-1P ztEKgW?{Lm}Twgv0(b|5#^<)B&5KhNZPwiME5Ef0Ll#Ig6&QrKSlFNopmvWIRYF#e* zp!8dsUtPN=L<6a>nB?N5X_}S*rD0u`j&lGzn2c-CZGn^twEEXtoVeKR%Tjd5s(;!J zlrL}^u#S8U9-0`3$S3-LHC?T;9V=5qy%SSN1$%d}+p@`lj1Z?hwi2Sk+`Rm#+EzV4 z+}DDwOn+txj^u=o8hjiopEVWq%Qe|L4h|TIWQ!n#z46`?L4<1v2+>++v^=ETBO|8G~?tL=Dg|6jb2*6-tE)! z|L_C2pJ7%p?cvPjbKH+a{ksIMjgvG*^+ZESSxt)MrhY+K05_(Nd0-R3b*kCrP;1x$ zZNHBJMokp1qa8(a@bW zNMRG-AE@N-KLv?81>Y{zcI|mu2=tDf_gTGaS#|RhC`3I7gOYf%Hm?keid$6~eSZJT zW50fD$5l`B2GDen?e2*h|GDs*_1-Y+8JBap%#_)QMRxsG3MTe`mNLp^Oc1vI$C?f8 z5L4nBr6TXY!RXW9`sEo9jc0D-?6TCSbk^Nj)c zek*azc#LKCkM&3s>SR6DQW_%Dy_>TYV}X))Xii0-wXzq&NYH5E5`rf1=p~ZOck$j_ zOwKL1qRc@?=cw&g%7qr0mMVV)vsine8?}zei3$0x-7lqy)Z!aUKjW(!;tXQphxJe$ z;7`g6kYw){H6mFOD0N~PGN0Y0E)?3IeKDcFgst9*x2Z%qicQvk9!-;J+npyC^^Jr? zdi}i2V?|fP!v0OBo(Ny9zprkxic4aky1xtda|8+`R7}<*tG$idEcPFk>}Ma1^PglN z+>EID?#EQjS904L(iY_d>bQgCwmB4}8)t734|iuydOegzwM!3gQxngwOaOWS#+r8Y zZ&680(foP@i8aUjpQ&i2)yP?kMs>O#OZ_Q5)C2Rp!YXV zni&dndh2!Gl$5DsBzt%$=E1rtN4_q2!`EvZ)NE66@>Ks75o%7aC&aM%oMmR;@7u-I zmC2fhJWY!YIh;8r7;`{lq~Pjief2{RBR~4tm#a!s7Gnb$(yZz6;_Mjz6ty!OJ%med zI&XSma*->wj|j9B#kq=RJMeXu9y^^A?^XXbM#VpO7r@MGCHk? ztp-w!LoS-6lJWqbQ^B=VhuEzx>>-R3qxk$fT$%}vBjS}yw2F=GOTQpfd&wQSVf?TD z1R$7w)MQ{|b6AjDXhEmjy016cr9r~r7cyz26|&8E2#nY~X_ygZlDw9@`s%vB*dqWdr_)_k!DUyf68W2i};d^dtqa)#$4nnN0 z|ES^j1Z7EW#WF}W=P^<~c<|4OXkXl}O>(_zmcX){{7paMtNMBVi*DX!Or%@#)lVv%o({hm9F_+`?-i6(Bh$s^}_I6acJ`!Wmhas ze7XmXXp%F=0T(PB0?)tOf$!T0^fB79EMy)gET}04sP3G}Z@L#LR7;&n?Ik7^(~1DwVK!Ty|ELPQLq_f~^=fX91QyH{UdsvCT-U;MU80ej1zNm{el<5R)srZgqyx zyC5PuQYSEXfjK>9N`g$7vY(@Sx9fPJYE2R(>iCMZ#|i(3!#U9(@HNjf7c{Ox6);@W zNYN;!P}h03$G1>Z-I@(K*#F0dtJ0?O;&i6am7obt=j!B|HKO=G6IH|Fmy4X*gTz>x zPtPkgL)`n!6`M6rahWzKbVf(-^fQb^N){TR6WDAge9AUM>6`{ZwpegK+s>fBg;bx( zMpOPj&vU-Q+TB;u0X|62&BP>N*QOTjVbY^xvq~ErgHTjOmTsU_b}^l4Z<}z>ZaqCw z?$t8f2BQ&nPn-VwX#*g6J4Eo?o0&}Bo@-6g;AfXILR-UlKo_=9D90I)TtxnoW7a2o z#OY*$M`Ihx|NUTgBYlYFdSfT0RYGGEL_LcYp>H0|vO_?&I>NrK4g`Z(n^4I$RM3|B zyl?Zp(`=Q4y(MqpOJMEJ7;l}-)dXze)7`rW<_LRi(DSpu<2U&aRl&@8ZyL6u!$|Uz4i1X3;L*9po zV|RONW1uM*O#-R)bD&ukF+qhAPhtETw5@~Ljt31q!!s_h^&11wx79$RJJ~%~dm`jE z*4$P6L(3X7LHpa(tm5X9Jj{^**=}zlZVl@xQ@wE3M@?RbI0ZLo>$oS0PiRT-^rm}( zQT28vj#8Mt1xb`r9e=b^iXX{Ry7!_6%8aE8*Qv+8 zcs0E9PJTV3rg#!reSI_?Hg~-n;YSf)NdWTVEFR!@)L+_ic?Yc6S$4LlINh6>@=jE# z(ws}EeU3>+JgUxL;cv_CCpX(6V#a6Hac`oj) zM&9+*B5b+1MXnbFy9c1|L1*6qRCd3`)!~HYc#%! z^%q@M<)FwgJ>Fh`190I8(1Lv!?ey=|IDREs;!IY)iel$Ihp|3okQf!-g?v-+WSlKU zK5;(Z{kCK5!Rs_iq+v$qF6B=F61)))Hp=*Wnd~u#FlYIT5bo?XUnW;VA2~?k7xZhN z`|j+z0QTYmBf|=roeXt-isb#Qnkxp=fzSs;{8lJ2GNY52&`C=Hmad=5V)e@D2)4nG z8J#uMnyy8YJoK{|m1<*)S&5bRlca%!mcxv87Y|ySp{k;Ls|k!gwK85{Kf(uP?ZBc# zuf`0i#$*}?v#3G(jW*~W8Vf)8urt-T8L+UFL46(l(Ma47oHdy2bX&tKj`JDX&k~vK zhc6d@$;fOU4E!?a0HdEZM90G%1`AxeX>#ZZ_+Zi$&dA*jW7AZeXaY{DqkH= z+gWR;HjGT*@8Lo)N0OPZ!;+{sYwhIGuDV(-exqXCVdB49h3ilXg8LYLMn)w&QEnG> zV~>^#;kGgES<-PwGwhEB=NO`4;t3+;su@G0 zqjSdbnYByGTG>W-*SY^ah7!Q&Y!UVSLkvZ_T@ftq^&baO#9@3+XxUI2PN`=HVF3<4 z#$)u`Xvo!-&||-!8voKFU`Wsna8YaJiWSffA9Q$U<%(cnAky<(4}9DG)^5e(T#>Bxbf_JjMNpZ9(Ak<6JV zf_9gH4hs@0x48sR_E$VHw}1VfkTJ{k=Xn~N*P4utTbJ3+f}T=~1osO}(65OFnw^|s z96!_fnm7(*Dmr!=hy~6dkMS?yjPdqG|G#=rDuKg0FJ*%CJbVw>>T#`>2Wyzh2PP5~|X~r{L#yJlBq^xbH z^*9GK9{oLL=8^E9$B1M_&CmnW*k7;ICvo{+j|ae9N5oStm#y>X5gtDXgFHT70*C!} z!dZ2JFY6YY_4Mf@i|&Ob&04(wi&2o`lN@D_g0qYI<(unE#yw2*fETmrV=V9Qgo}VT z-$t6Z(s383zJgXwfI6JAz3*u$ONLK!5~=;eq3>JxpJ#rAoDA=0`I`-6d5+9;{PNj$ zhVB=5YyoU|mhC4JCieqW04&WFG&hp|1*q^Nx`;0M7dJ@XMMnulEuQ&MDeMOL8BTD% zX|RCn*F(o<@oMdX8?1d-#Vt-;JBV8-i%Mlu9UnkR6Tc z^2nE8PyP_kaiIIykD*6I{5jJkJPPZcHpMT_Rw`PJJaVY;iZ3^i(02trV%1dt1br{o z1-p8MXjkBW-ZM7IXHq(!MFl4!0`Fa!W@U$@NlJt1j6~SehaX}jK7V^s-8~IYI1%3* z*75Lv17rR;Fy;?M;Qxm+>}3Jbmw;c;zlR0^6iw?aa)AaeXR37@bgp*3%^3XoOYE}& zeG5a^jk;$F1{S8S$tpLN!>^s}R`K6=f-^oX@sBfy4i%?rvXj5q^Xs2qk1;>Ob^iIi wAmRUt*rXqcK>vIl|1uQq?_Jvb+#HKz>S9mWJVEH*-gg>YH@Q}R^}*Bs1EhssTL1t6 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/chiller-table-example.PNG b/doc/output-details-and-examples/media/chiller-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..19e16ce33d148c58bf9eb17bf68c3383e0d9594a GIT binary patch literal 78530 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%0D8v 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 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/cooling-tower-table-example.PNG b/doc/output-details-and-examples/media/cooling-tower-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..546a79f148c06754188985df9f410cc0ec1d5cf4 GIT binary patch literal 33030 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®RxhJ7fjd*2KpUaF(Q^bad~F%+#3~N^-1- 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 Ac>n+a literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/plant-loop-table-example.png b/doc/output-details-and-examples/media/plant-loop-table-example.png new file mode 100644 index 0000000000000000000000000000000000000000..41cb70041e1dbe0d79a1d037ae0d72ec19dce0e3 GIT binary patch literal 80211 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 Aq5uE@ literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/plantloop-table-example.PNG b/doc/output-details-and-examples/media/plantloop-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..db691bce5d474c773e318d1cac174351ae9afdc6 GIT binary patch literal 7304 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 VC)6d%z%^pr<@EVe)h93i_Fu2ulyU$7 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/thermostat-schedule-table-example.PNG b/doc/output-details-and-examples/media/thermostat-schedule-table-example.PNG new file mode 100644 index 0000000000000000000000000000000000000000..8858fd6d0bdc8dd85ee5fb1f28c3df5bc3cefa1d GIT binary patch literal 265608 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

%M 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 literal 0 HcmV?d00001 diff --git a/doc/output-details-and-examples/media/zone-equipment-table-example.png b/doc/output-details-and-examples/media/zone-equipment-table-example.png new file mode 100644 index 0000000000000000000000000000000000000000..2e0df05c6d6e75f8db39a09597dfb17c6818b443 GIT binary patch literal 63620 zcmeFZ2UL^Wx;Bcsl%)u$s3=v?1xOV^kea0k7DN<~4iS(h1ccBbi4Bl$qeh7I-XWnT zDkV}Qy#$DWBys|1ei)-iX?Hkw3g6x-@wbEwmPI%cI&@hkx5i+uP ze4a0>TkQF=?~@A~$Y6taD*bKmf05jOE+y+0vTm5_uy*IfFEiu=AGrL8<7gGlaD}qzI(0nFRvH)bSbh6B!9+fhy=V zoDyLhL`mYm*+yAfty;4~>+s(p!!p+BBPVbErI}n;m7F4_J6rbCxW1g_JAM*rmZ$Bt zDikT*)J*-&H0F#sw?p0%P$c79Y%ADNH)!*@D~NB_hjeLgp#Oe(;=WEtVJYU!WXha( z*3~b0A(dn$^#XB}x=6;3@p14Fp)QbSM6QOte2u|PM}51c&GU6%hN}5hol0KaJcbni z-(SV~6?7mbQhIf+H@H$FY!IM zZ$Y6)@Db`cHz{pO5w7q# zFfw#3@|Vrb=S>&2*0Sjc60fDcgGEp~yJQ(oPrVDzkQ+}DMyB&Vs$Z~eztQHfD2Kh~ z)w*=`E(G^nW|1!L#0&$nO6V0SOR=7}%5mjLLu^--X^kAkWb-}3Di*6q?!HQo28gQA zwARKV87b%_BW8!pRhgKKq z;j1@fcU-vF7u?JQ+r{dtY^=ZX&K|9c|7HZmcJLeD1-sLZ-fKQAw$vUlBemR*J5bOf@LO4PBSvQBDZ_%# zSXC`rP#ybFoHu#`>By?%0X`HjWjtxD0Vbtq*`+3DAsF2z+5s{7vp#aFi7Df9Tg30o zZh1lsxi7d6mj+6l9Z$T>=G17hxU%{fzzV2?@f7$=eLl;{i)5sz7tOV=g&BLkA@=ly zxjh$!CYFAv@yr`W69;^ zjt4YNM`*tOdAn$d7F6)SRg|D%BY{q_AA^KW*|3m~8X)=nU3D_JNDW&F-g)e(+j>cG zw*C~YnGkLlxHLAie&g(#iRnHEU@+{G7{@WJU@8}Yr$^lEFckxRjTYFfcyNLGOoFqi zO!#Cr`9v_&7l878m@p=C^R11mHxrC3D6ruEYuNhXoW%CTN?!&YO^%cvRss1I_dw4$ zO&xOugc-MHW@LT9oc-%0`XOseS#RA0;=n;OmRGfXez}G+_{{W<`0)?%(Dv<;XvP~@ z)sK8`apV(H)jR?Ed0%w%F_`Sjoxi;Cb6Y*pJL9kY%Efi-Y0&@U6aPdmhjy57oWV%W*oGw;isJQDuruTJ4k1OV3mM0@WwB0V$HQS3D~ojqmG;J&e> zImZZ}cp&qkl!tP}x$8y7-ow5(rkQ$Ujh{3+^G~T7)!*r`=H@*441CEiXl8PGh~JaH z{=lLJp6rWuPUS$EduK&e)4f4BZ3bif6>{;_4)WZ>v{7v@Vfga_qro)qMSlM zY&pYk|6*d_=iy7`pOZdurpML&Q-BI}H$GinRbGpIrF%2&BM+bPXTvvIT%$t7Q==y~ zIRPiaKNH!vCO#^x%8fXb7E%0cc+c_o9*mU!@!L01 zE>B*{5zoUR`?;Q-|G_*E`jYr#;P-*2r@m`)3Vp8sv3}zRJ(#__#n>u-h|b{TU;f7(d58nqYHWu5n^9YQ9uNz5EmWinf=2 z$zbC=xyi`K&)In2;UMFEpAF5{Zn5p3u0`XcafE3a0+w8W5zL{Ism$Qnw#OBl>Ai`f z7%hcnSkc6x#)(Go4kR^_v}Xqq?&!zQT1oQ<02@tKU|Mj!t}+*89`-A-?>L{Z z;XdNpmG$&foceP?_eVL?n3s!dGR+!-VcpR|;X8r=dRT_@fYPY>yretGb2e}ED!s!n38xLn z5j-ENOdd<b8Iu*NoF$2&*vYgzHSjv@Dj`89Z&&WC8YB zwQ8L1(hf05xp^J{znLIpn8{D{7DiX^`Nq%fPlLW*fLt6S-)PonafxF#W0bCoWN_VY z)qmZa_2qVZ534miv-05AEB=I*Daw%scjdf;m}94)%&N-N&(}|KG4cD6 zdE+*Ll}Hl7AFhgc)$BfWt`)jM91Pf;0>mJ6PTyXeOw|0LV*K(FF=^v%yPXiif7wp= z9yDmizh_R(JpLlFZ{Uk|TJV6j=4a#fen*T&I>uCt*84|-Z}WBf@XH{}OtQWdgoexA zeWnX3#EE~id&_;Ph(re_5&75Kxx>h9GSIi3E5iXj!0!IcW5BO1qFP-IWi{wmWR3~E zWa`%$WwP&glKOR&7>?cT4)0IjwJU6A*UVeTrmyZ0d|9s{yW7P2a|$IVx6Mc3t*lz_ zUD{QP29s`SR{cW5;!-T-PCT{1E9~kb4Y|q5^%`}(wkYWn#x*lj!2#i3GuO>_ESB>t zj1_P6=(b;e93%4b;6ufqLAUoNCc?CPayZm64Y47jfkO?1B@)&W9PL5f7OC2(4vq5L zTeNe%xdQdDSxTF>bTV3$W`9R*m*>fHGwRkZ6b>KBN z({waz^L`CNGf6F}QkGC!oBnR1EYtb@xUr$MOIh!ZRXxQsm9){&K9+vq<8JB-c*Q(Y zI>)}2uSeNrR0(V~Hda9V!cadSCf5KV|pJf7R2f~K9QrU;5DwKQ?T0B z_W=NUs^_NQ5yT9nkL1^^=cc!0p$izZYHyqTxRMM>Y&b?%yh_ksT-dVNtX{C}WSwy; zxOO%a*h$Q183M0|OL`@GlXsQVR<#@Hfx}iRWhM~J)+*Sn{*vnKw3ghzIkQ*iUv!=gW%)YG7-{nF8UXw_6Hm0W2Q;gpvc8{%;=;pZM zrEMrG}}9hhK+Kh~(=w5YMvB)PJDp0uKk4MB|HP}x3m zes2&~iJ@|<**L`|7yH+~9~uJ8)+(QRmkGBIz7uCzS7D=N>%2e^cxmt^>z?Xs*%uxH5{!`pQV5^X0O_lu_a&{8hv-#V44}T+4Nw zqW(67Ae<5#8{U6e?JyJlR4p9gA-tg_MFfyWM;3lIKB6(5=pudS;k7TcG22|^fFvN> zDJ#mKMD?UCPXxMCRqs{BIWy!G@;rRyzlG(xCe>(%e;cWsxw7l29*|M;{&l~;Pf*sd z<>2cp?M2En<+-j?)KqM*om8)mK3^U=6&4E~*tAW}J}3p*G1)nNpDZ{lOS%M*u623? zS}{vKyiz_gH35w+PMqCfO+>CM0R$LJZjVDgk5q0vCaJeVqw76A_ML^l8vay$kztE} zQ+u2Oj7?@QYo{%2!FR{}|nl!Q?C0;8UoQ~0pWYo(g! zs;pwN_0g(JiqQvuy)relgLCSjQdVhtN@oUvo!HYSC6T53j-x{2FYn4YhD-%JhkLzC z2$vVBH6QLp>G{a{lL~9H5K3S|LMYp639VmyZ0;MxfZi4=e}6uB1Jsc;;k7C^tOSYH zC%vVf5C_U_vX>T@UIdFT2#AD19>!KE`1%@i!ws{QOg(g2rKJH5M z3fLk_mFgZrT!&Xrnkst=!Pu?adRn5uWG9E8Ws*7reN(SaHD2fL+SZV@I|IbTSElB&I{a&{+OnF-@+aiMw9foF}W-b=WEoRnZ27lL2LHoM!j#_DIu>WD;pbi-PK zZ_TaL{H%2GpV+G03sXwtZW~40+8yO%j}m9kbnV=&FlsMZ)C1tO8*X?4Y6i&u8mA3b z8!VZ5P&HA*j^TKsYnGA!RS#hD@_^5!nJRc59cN8dK+<{}axO+r2QHY(YbN}C>{2Xu zFFV4{m81R4#NX+VQ+Mh$k-)Ha`_^49arA{9-HGO^(v6p}8mH~-s=n&=Hkmp4ieBm>Ovd8-l>-;-Lusjj&Y1B5AstBW_?Qto|_&nW;s^;hLz; z7eKeS@>!cqMbnSJIcu#FhVoEDH=9m}ZGi5ug*nlXKy9p&BPw7Y;44LV9P&LpWDD(S zVyh3_-Lkq@-a+^Zb#nEwAI=*Fe&yR@lyrF-pNfCCTFtuIq81)%5b&mk-R1s`Q7tMV zrf(k|np++kMzk9KxI7}Ei!GwZKULUC4a>OGD@<{F42=jLti8zee%cWH=*~0#d`ZYPZzwsy>HNHQ?D6_fpRh|i$&RzG zSVngvDIw%&D75O+u?6at9_e0tIp`3$%@({E>};mqans6Jfl-p;9XTWA_YhTxu-I0e zoq`S5^!%=LBY37dccnjRm-L&Bue>j?5`8QDFvq9vC=W1zl2h*|sVH_OmG()0cj7+U zSk_j2nq~n22AK#q*TYcMcQyLMBh^>?U2YCyXl#1ilpPlONQC_rQ2yw;w?t7 zQsa~yHJ6tU^z1LnLkUSSL3#9#S7? z^>V`%>y@?&@ECWg=m{MD%}Aq&CW%xsarhc&&T)Q!EH{jIp5k{ZRsicH{;x$DJLha6 zx3(>*OZ>gVg&L;t zM!W=J#32Jg;GyX#H_QE`+YEZYTYR|o;Tb|H#-p?SD&pRXVdxxFTO7y#ijHkc-gJF) z%(%FGA(gL_`fe~ex*TnfKSuy&U@2aH{h{o~>4OgIBSh%Sa#O%XFVp2(QGce|dxNfC z9bNl@+AmlAd~;_2IYWXqA2XEh`l{vPIt_6V(}?G`A(y+~o~1<4zaa zOxo?;f>&HKK2kMx{Q;NneNm*|MdvNw_qlQ__#*QmF8552L=5uYcAlCPUY{vdXg}xl zne_WE^Tqb#-T}xJU5hDij|(~g;bURWVm*JY6a@Yj>O671F>@_QVOVKqJdSdAwXw4q z3s3^vkDqD(I)SdTmr!fM18>#&&)$j)q+0I23v2B0 zAKHO-F*28WV^qp6VDdbM!`>a=e#j$xaEfovrfRmU2VlB9*W|Mu?0if8GQY3G1)zAk zH}{N`uQpyaDO79K2^Zjhetalx{b97;vxiLI5(WUrc5U#&Z@j5AGBV$?t?d4}x9E{l z_=+Mj?`jA_Cf6LGrNr|~;Fe=EDz|0Y8);aClGvh3La5B(7`s_@ohGN9R(277$8Vw} z(CoEwqKt9KFbzPLbW&uXd}rpHVH8se1c|AD|J$f?S4*ca)T{~p0h|I zw$vWbmE+gZ0#<*mQ{{e@auSC8RK%XE`7rBGx7cbPam|qEiJF+2P}zzoiVZJi9wGJx z+4WfYYf*Lvc0ULmUb&Q@35ZX<$uDe}nn|-k0;r|Cr&h@6wIx7wH7k|m3$z8wCdCC8 z4M(ToPy9XD{Q+1+t?LK(T%Upo(or)x2NQYsKP?S*ZmfIG%W-VauGr2u|I}?<;Eios za9#E+c|}e5aUGGEu)in$An^gQ&-mq9$=ad6020qyoln0KH>O*h_C|g3Ee#G2F9>W2 zJ;L>f*CJR6Vu88%D8dMX`Z67bdP(fvPm!U_=YI(t4t)6+km1>R`9oOXmz~s@ukQQg zcU+lw`sz~NIjt{db@~$%L9>U{IL6CmKx0t*8O7D5IFC7!sD=H+&Meb(os3At?Mu@- z(4F0#jW|TGqH_JEe*fJ76H9GvG6{!RXRj%SZt0Do-)J2Pukv@W&-AqVF0hAc#mh9o zWI_d1Z_;XBN284cT`sIHpdPXL;2oP}ek#bUbc_ZBdo=m5q z0T^gK)VE$I1BV5%#*)8AU_oe>Kbzi^xD`7ChZl@D>xfTbZM^7}qvjPo*T>~z!tM=G zk==_ehCL14NNaU1?9m2cc(|6)3l+gk+MuDu8p&-gWm)v0%gc0b(b(HC(= z8U9~hwH!)HPr%zM)vBu}?{?#8bba9>BiN5jaL{$p`#I|tr1dRJf6STxMpvl(u!n zDFs)Y6Z!QG=Iu1ODTMpOpTE>Z=snhYEF%J9&7@JPzvodRAQO=N2 zS9AKwE3T2!oBLizwY3QBKD*)1b%W({gtC5PqgaMx%g=QFLs(fnFi292>szE)KZ0~C za{r737gJhGn=|lmNRVU|!$t<`8}yYy5lZcA5zt30qFg_K>R?MP0<}t0+#KfqbH;y! zA;;jfw5R!R7PRaet`!>S#oCEz9|MGTw*2~HC{kJzq~GtI>z3~F24nR#lfC(RO-l6p zQ)*FOY>NQ8Cp24&|6lhzw^+ul$OEI@ESIdUf?;2!reG4hqs|86F30ij{0lsNW+hU3BQtzz--{l=g*?KK`=U20 z%1){BYwnOXwgwIS?@QV)iMqIn7!-VqJiFYW8&N$LFgcoh_2_g3zwy<6hqxl>dRv9W zU@d6&fbPFQwu5G;qc)|b@*Kr4t$VU1l(+4~FI1ET=cG5>jr^@2vGR@klw&2MAG8Q{ zUED6oqJPJIYvKKRsO#BH7U%@UJIgI8;=q5#^m+u&uS<|IJpV&|=6@mM(8eKd05H}o zHY{+gSiE!lU(z;z)1`b4KC{~+u%^iBdgGt&%euZQbFyso^O|s1ctaGcHpHPWS4Cs`1{mQs&bl|+5r{KZfk7Y;$x z6S}%eVLjBQZ_#Ouj4>G?RirsBVD*N0QJBt>ls~fpr-|$oJDz}d(h!u$Nxzz;dARMh zDd^^kUTW2wgzGPjUg=aqNQQ>$(er^eE?|7-1S??U0=VXw=>kF|**P>3;VYuxjy*Lp z!j_F2(O=9K<1drf2GXlO8Ra%B(=nms!}6PQ8xoM=fCa|IxO-G|1_~D4a2aL7QzlWW zFj6N3Y_PPR^tLBUou&#h87ROZ+Xt+iGiD=#GbZ>tbJ#-2wNRGwjD~f&?2KqOLvAew z`4~1cHecMO=X*EK`C-l>%hw#v%;}$SW@69i2IhH=xYT~H6Vz9vKONZBUE<%d)koth1sT(;Ogt5(`7 zm4e0hRWznIS|3QQdvH+=bsgi|a=$e|(%WT`_i`~Vvx%5uty}alUoEluEFq~z0Y4#j z;63lxaxd1=yxk<+*%s+^dcen?6qnM@08t5&Gh_(UUCXYo&>trv$`^+r#Ga?=2+NUv zD-gH}E8?_On`#p3u}nqjhiQ9@2)Mum$`pLcMR8}|%LYiISS*I^V9;1RhvvX$F*)EQa4~Yi*gsl7wy2j?n|VsTwWLSQ$*HJ5^GxN^ zRl){LnZ3eL6dKyHo2=wRVn@*H+ko3CT5tk2N8W_Lfr|q@nl2)%goS)tp zxnx1jU%mw|MXL4Z*@Avjh%=xzsaDV3m4k2JHbszPjk=$W9*y5rJJ<~QD!7IkfNwju zcTV02nu3_dT;}t3@T#-*y0A1Q}5MVL&QrG|ESB8nYy?b%SNURTW(Z+O!Md{Q8 zV2O!$^_ki!=jrmA}QTzlfwIaT$RpHi`7=5T*u&nrIXJ1QDc`&>NF5RCwo z@8P3O(X6Pr%66iQi*{f~!109Dh*Uj%y05EO{335_X45Xo8Xi_Ces;qRRT(AYBs3ns zeG^y`hYfEMf~M{;PF1>lSx3-^uO3H+do-k%mBqOZjvD)?t=^HxOF1qtB0WpD7G-Tp z&IGK?|16+?#Mog;ZC5Oxk)xJL^~OkRrk{U0Lhj>Hq}jc4;hUYvBlW?WsM48|#gGyYUb}#m@8j@! zU6OY)*?rS)JziPav?ehHW@sFnsDrs64>GzzFz`d~bqTIA_%|o_?tz5JDzfx0h4w8V zud;CEsl1zCmW^>cNP zobk`1G$nn)O|gv80DCJEX|(BGr60-ab!3e)V`AerX-q|x9n=64lpnj_1{uS2s4XmA zDjglJIL2Xb{+WQHvWp|%ENwo%G`6YdIQpuCnH%@HMp;1Ja+CN8JAQu|pROL=*^`yV zlFBt|CSUxc3!I*St36wojYstBEa)?kdC*-2;ytm^f;Vu`p@*y5mtoGrtAqo>ZJOnk zyeefK(19=qI7((g(;NJ%<&cEYqWe(qboEMGp} zqjtSF08W&`QeukSl1qt4wb8?)4FPT|99Wow>e~5<#&0===JxbPc0RA-1zD)WiWCTT zAj83@%j}94frwrg=!q78sI{^uMoB&{c$X|g=PwyXtc`4RRDd}KGa1r{(@@+qnIUwX zd-i`gKc=8TU%iKy8!L~in|_t*uF-I^E3Q;)86;GoSa}fF0jy^=cIJ@D_{S#)2S@J@ z3h$zYF_k-8O^u-sO*3JY%Ea*|^#;l&7}XRtHqmW3-*Q3mP(QoF+jZ%iL1m|t>wBeI zP^30Z&}*@$YaWgQCKr{j8m#|%ThK+>QG8cGS+IU>F1Of2uVrz)wbSPUs5lC3+>>uP z?sRLA*K$NVBA_u~o?*P#FH1Wjm!+iqY{oy_y&Q)jEING#uGzR}vAJZ1fZ>;Sl?D>J? z88jg@qn6aTamf3rU^0&Q16*(w}jwEWww98+u0po%WMkpO<7Ut0pC@Ib!$ZLsM(-Bv_dPR zL02|r$Y`5GNKgI|eV{D$_IZQly%2Lk=mL*6O%5kB6U#y#=oOzYFb-=MRbIG75*K|1cLi}Nn!Rdgt=}sf=~_8SjNWhm+KC#2Wd$mY$@rgU zCI!d%Czto&Ml?KQP31Cvv!j~=$De&?Yqj5~PXC@SM%vEYA30~CemdPpY83WwzU7va zUZd!&1f&C8?*+4k6_do}lKF=26-dv1aC|~@BYp-V{odf;25b^P@5B~H?*Dfk?UZkj z<2d7O+qkFi-r~}$U@%l=_zJFxJRm#Jes{NaxfV8@7w=_C)f$K$F%yDYKTO|_FqcW% zm%zYZ*vPZZR~4xMqeKR_+sACv;L(|uK7r7?m4uL!)jR=n*Ed)O?yn%fLSkpTKS4C$WY#@$+@tS)N_4{rEnBN`2TDq-Vk(y)1-wd+T#WsSWl z^wj>gOq>hdOnWhFLdLQm=nwN@(U^=W`_{|KUNs`U$%^MB(Jw}^o?KHm`08^(V6})SGa%Elm5^?$|Obw3bLKQHQdwS zFpMXUI4^x|x;|F*NqSE|De@qQeScfgEq=rOppj{rN!1^a{11_JSFQh)@bAB@eJ}n8 zt0dcmIZ+@31;k`vOzL&|onIycE{)K7$^%bexOVS zW^%M>iN~i9WLu2!YyPCeK0_8MwKzqNf51wl>f2NS$ex=+a}pYP?NzcS2LR02<6!T$ z0ZON>=Fb)a+Q9d2C}_*?0`{8z74^vsn6tQ|>lWkU2Ij-;@6zb@9k;nmgIEizSE8~3 zLlBK^-UHV^)=cexsVncE2{oWwOqJu`1w^^NFHf-POm`@kXNr8&kX)kV%?_lC=ZMda z7iI8_q~pfs#die91=6AhE6tp4Z_eTEI;(Yv;cL!~{bk`P)+`&ES%5k7oALt;f8%a} zCz}=+kA#@O${0T(=@nq_O^KMyhtE>3AiEaqB z9+VS|+}QuBQj-Xh6;w*&5&OR({h0gCqbL4`031xw%usF*k+=j@rzb)p!d1^3?*aWQ z6Tw>kHa;!4zl+E>jH~t=HqscPd*1F;?ay?im*(hUzySGg#ImwH{wyq9-Cs30eWV z&QMvic-N#^_~xV9#^2p+kZ|8QdP!Q1ujLQ?lga8?v&)Mwdl9ZrfIBD3)Mts~C#b$9 z#kP0JudTQIiFE5gG%ior%JgCQys1uxsdjh05eiYx?=Clbe>0J3h%2Ki;R$5?rt&O3 zg;|16rfvI!h3kzpa8gZ(#A_aoX^TkF=n@fuN$rDGao1l;xJDq*?6NpzgNHU}3lH3^ zzzHdt=n0fg(3irS`=Q>bKAalChr5DteD++GfeOW61yf{PxDvZoz3d(DBd6XI8s!c> znQldKD)x#u_O~KlxrF!dXdmb|`jWtW=hFkZt#!W9o$rzKpVZw`oJ|dM8~GzUO0?k_ z$H&F|QN#PKY+rqk;TeE|lHC-`PL2AbNo+?Joz)~5x42v8WtI7Z4i!`zkFn_!*Glqv zZm1|UWsC5sG*H;l_Bz0002!|jt%Lf*I{Cm3O7Blc{@njA26YO4ta0o-j&>A**2{Vu+y>nsJrXIC1=Z00C>+1J( zz%av7wK7FpkdeYl^<`@Voe8Vib{664G3Q6hlFtHJH_uhFC z%Xm@h`}ma>_d7L}ER_fp69QhSpySn*kLHh?}*Vo?+gN(O;w5Obj zS}Ryf^Iwy}m&elJ0{dAS;)Y}P9dfjoR-Xr`$|ror;7pL-=9dxHf^9koMM_E`O>}Dk zFhx|iNAYb>*o+jrG<7}ts>Vpt@Ux}tl=mauHp-`wc{ySuZJYi&A)EB?2?x?KQIbiu zI9*g}i9lvE`vg6%c}bK<0Ht(c`kr@T+SBMO_g;af z)4cMFJ!a3=zDZqFolLYu8nuoNfyS(th8`jlY3t(j4E}(lTZhtz45ADB3ll;;N7A^PkeCTW zAk_n3zo=s1B7^4HUHG0pYo@p>WCFI8Z10%7wK9fF*sUmeZenW34ztnMoAg<$Un8Vy0TYN*4rAUGV}TQit;!O!HRdX; z{++AcDJr(7IYu%3+CO|_6Lf<_ z$H^@*MBo;eliIbJd)QwV0FmJ7Dg+r`H^ z+E4isotfw{W)ODoiT0b>3`ctcbtOov6bjPf*!iv4wvnnY=h{#uBk8lgx>7B>LRHvW zlmbbI22#5;-|~XjCj;)UrW=V3!28?Oti)5^tv460yl7J{1KH)5ZZh6rc!J479iR)% zqxBaZOBrBDjjq528ynho%Iw!Mla*`b@e3~q0ucHp{SwR88qEgfZ zb(se=tY$geCN>g3J)tE}=S9-v8(%zb?A&_N^Py5mJaWQ~G~wuVTw zEB!u^u`wcxv(-kY>ws57&Z%r;*<89H;?I(s|CZ9)A5k|~! z6N*ItXTH5Klyrl5C%qShrK-{zLXoT>1@SamvGT?3T6ZA<)G4HR2HUfR9M-*Pul?>-HHwE#g=!xTehfq!r+@t{|^ru-$z7{;_cxLr9 zqw~1)BvXBL&H!gzLDWKt$sz!aUSvFVMC5bmwZCt{8lA%h{0xsCcI?R$KhctP)BbKy zYk1F71trZKkNqC|NIunqzext~(^txR%rS7$#Wss;8`-C@9eG*Cwd+9SG|Mhra-tYQ z);%+wX4#!?>sI_t*;Bzpqi7=dF{@K;0>iBq?QicS>|z^taQUzUJh~P&^!o3>r7@33 z()1VUu87AT8}-f{6E{H9c~UiC8j*)06kW3rm9#-~aCf4=%5d#ip6nqzt(tAA1{@9V z9Og?{*{y8ucOmJ`{XQ0fEQSMylGe(QzdgCSU9Rfw?jbpTC5!S0TKE3|yG*-+P!5ZI zqV*1FF0Is?`!<8${HPt|3bae@9m~eawoM1WhLB@}Ha$i;4nM+4d(YuNio+eg61X|z zy+bNc?-c3LPT2j9x&~ET-X-Brplg?qXKJ;Eg%MgIpgiOen~^6TQnbmLRqYAh^XDK?6LHKRY)}OL8+GVljvAKON6+mo*xS%l>{oN&9&ZB8` zZK;3imKK$-1sY?7ndN&rPrW6l4uyJN80s|oxo7jX zCaB-~qzQaK>s|A@_-VU|=Ay#y7|Tn(plufGDIhTTZBcXGs9lQRy#DWk2Nu{rQPuvB zvn}T;vvGq+(T$(Lx&;~_c`kp@ zgf2(nFumsTN^|WGadKONPCxM9^|$Ij^+nn1TuD&)iLbq4k%)`$j|TPZxWN;2Fr{YMCYHSUtS#p!oJ{j)E{mBEvB#HE-oNpN3B2pG>$6xBKzv?7Ga+D|YHrLc`=q=vcLvu(G*MNQtxz;DdecXfG*Fe0@N@i}?{8&p>7qR0c^T!c` zxW@JyO;g{~-U>qsKEGdnvtl`(HviM|4^nTB!4klK&y#nzAFaCsL$8>}+BW7%dB&Oh zxDR*D=B^Gb%So`i2=?|)^c6;m^2IZI8D6!JN840?WAuY)qw{tk_uI8nab z-uB8rF8Da4-L#-zTFh(joi}Gr>$c8B`Imk|JyWscVC_6Y)7IX{p9DK7D1E3|+&y@v zzCdybdHVUXzS2$W$Hj}>z@x&~?eIvK)e=kR9I@^OpUhjN8%k*BlJKI;rUo{za_xBS zjM>{|vzWLt!mwVU(Euxht#C^e8HWcvRd&i`H4|O8jCa zyD2xj$X?82NWX;?VLwYTpSqmBbC%-0-qsmj4lj$;lvO;eLgmX=is`}3rj2TT3)1Ob zE$xfNpl3oKcgFEKFPqwX#|sGJHK!^k8_G&a--(~E7}qJTT=7rc74)}QB4VNbs@@d| zM6T^WZ9kvUiIo2ORnPYEuWi<6E{?J|3W*>mJ4!c?Wa(uE^Bf>0O)$l=@^r5sytMX| z@nptBKk?nv?d!%InnBT+>}!8(=|jYUfYl_YBK!dEn|{_@ofe=K7G;B!Hgp3%seSEa zZw9}khxL6>7IIIw`jVO%A_7qvU#+5aKi?$Mj5J8FSRt^ALLN>ShGM*Mu;`GYZy%4) zrGOFGx7(RDMsd$&lbl%`JlzIj1UQ@f&^1{H^ww?5aO<};;33fP?GR-q~2;(B|C~v9Z z4+`({n5D11Sj$Z)TsgB8PIezlQJ$IXCd}Bbtg=NZ*XGJ)k=y4FfP*^T!Oos%JHz|z zTgpz&+S27$>@!Pmu&PD3>Qra?*1ad2E&>3S!M-%*sb(hm$+4O7foqSI^9)$Uj$;nm zrXG3e`5Wpy?ucXp2e)HcZ{~{voU|uc94T*E5Nw#p!q0b!7)GsNW}o=6ocn~V2k%N_ z1Qc~?8&$l{^!ATumjx;nHm322yZ6WaK*bv0YA+I}FB>n4qH_#0N+e(Rn zIuAG}Ow7IhN{_4xyaxVYEa#TyoA|DF@8kt8(lY@5zwqdV|4jS-C!bTn32fv#9T;R1 zL0Gui(Zvko5G#8M#5v#4R^2WSeRcvqjJd?32Fop-ZBti&P#YSmYg-v_(#Dj0TWVN|GwF%t!Zlg&WC5_*JRT9EuJ?h2ia&?kNuc3a9R84sTTz{tgIyBk1lD8lA zBeEhFO>(1I*|Eo5qZ;zvBIg2DiU$+tyHJg9T!BebUH-NlSW_DwJ(p5d4FFnzr_wa$ z2)RMuQmnsyyknFs-;b!L=-|ESlKg0<398AE1%96+7Z~^q+woLq)NI4Vw)=&*m4rg}iwp>rE zJTtrEHagjxjxt4^QkQMp|8yQz`KHYGouFQ+5$`1FzCHM^g80K;Q+Vf8taowq=gD8Q z&y#AQNI2kSA$ktnzJ8m87Ijt0vnsB#yZJ5H3b>^NUV$lkzD3eV#SQ+5U=>@E^l+`8 zIsW6aGS(6T${U;#+DnYZal+VFV}w^8h7%rGmG+$I^lzmY06_4HJ#rRb<|ID02XyCa z9MUesZO{r*N6WTNu`Mb9Q~KF*55oBXTS+VNfRY0e=1I_BOuC-eL*$0dwGT*|YlsavA2Rsx0YeYToM zo9h3#RD1<<7pE|${7Jt<7PPy#8q(D(2)X2x_nk($t0B_S^2*zAqKj5ibI$MFlzwJH zzc;}EeC{W55!w^1I%Yyo%dqe{t!Dl!pp9;TT7W4o8pi#~)-h!y+Nqd|%BhtlEa#W2 z(Q~lTiJT;Qx!g^YCga>(~D{junMblwMRs zlq$W$C{k1q5h+rYNDU#MyAUC6wfBYEJu%@_qG3|nOy$fx)^GTsFdhw;aNq$M3`v^dKYtyOu;3*wny{n-p zu8Cnx~SKo~1Ig^g~sIl|qwyd3ri&D=AmMuV%@_3UZc2X&OXYD_6mLk~6 z5AB%fBx39EArc2tb=arH69zX9^x!8|3)i+#=c-Sphr)47P$o+rrE>x1o=iPFE{#_i z11Xoy*K6$}q)o;Wk5hN&>WXqj_qn*rCStCt8Obrv>wkiqzY3y3*k$H5t>=8R32+R; zC{bGJKpY6e$NIer`T0AU*kEhcqRnOUmf%B)GbSUImB`!`c=pB(`;ywH8!W+u=!c(=>O^W<>G8Kj{u%cQ7W*d5M zIAzyTOZilvSRaFD!`m(}F=RM<%k7N<(p1I7z^{ucg7TIsuP5&wrC%hRdz2*ytGQua zudh5M9&KG16~nZipp?ppS}`zs6ey}X=_5D2f5*aGR{>ZW#|G|Z7c|w$94Kc03jMUC z3f#924YM;cpVVO0&IW5rmb{H&W1rJJjG8eiGJ7TWQIDgnKn}zdC+E7SwHR*+7XO%` z`F=HUbWNJQ^;Y1yhe0;)n-N2%$}AB?@gebvV+?1}D~jbK7rcXu7AFR^N^lnQqQO~# z_nXs4&=ZLfjt+nx_evsiWN0D+9K{4z9vEww87Ob+V@ayI#L^u+7>~v@;A5R-2ooHAY4>C0xC8ZS zr!`O{UF*F?5j%D%(tU$ToMrf!i6I`m=2o0@m%FQ9e{({OX~*8HL3X*KaphA>?63+9 zF|4DHl@Z{7*$2=+X!e#YIgOeNCeyE$50vvE<7!`L1+`Fn zQ;O`TB`0fB`Q5Eneau15)iipEwU$K^k|$g7NAIs-Tf1RB*L&C=3!baa)YAqMPE$?k zPOg{4D1&mjk?(s09g3zlFl{{w`h6IvHv!NxW#Q4X6 z9dZW$wEfo|;IlRKrrh?GAT|D>b{RPYZ`8iX8y@p5mAk_?Bf6a0fp)+TDV>qsWtsr{ z2)^^EKyJSq>aE0x77vSYO?&-aosTgWKdKWYh8S~THMLFDV-uyk-lkp zC7iO9nhrq}le#YIoE15B%**bFy|xxL+f~S{6*!`TN8@VGq6}YYff7+H4$=iVS;C?g zFDcAeo1`3IkkFlDDWromr^yF=;lV+LEXv{~0MllVq2Xec6X6c{&T$NSxSh?fH*iWt z(Eo7{NwH}TWBFpK=$iXVf}~zict={?3*J>}Gx_L;qMt8oWz^HCM%9;CTNbwmf0#ktK=eKR`lhSwGYOK z@iXju$Y*YxLr7e&t2C5;Uc+NP5>@iOkbzpw#)+eS;f;l=;PlF6K{k-9(%>H$sKb4E z-&j-vXb0@@KHjGsZ-?Y8W4I^L|AhgZ7`8K-qCNYfG1Wf~xp@>lk0Cyjyspsy{e zFs(e33x=Dk&8qkZPxI?nkRA$h=T=J4<%iC}cmbPm;xW~un2!t6RwC=2)J*;)epE%` zPp>eZ&Na@hBY>yH{gEfuQgl1w$2R)#Ktz!M&3Q;UclR(Mx0UFF4GF|2I2b|$Hj-~p zuY+mt2kz)Z98$V zkHpuTzoN=%HhN;XK&YNNu=PjRzFK}7?mup3<)Jh1U0h^zQr-DuEllVAjtQ1cR%q7U z6x9h7756&{%f(_#k5ZR}PmEiU!l~~M4m8>ghwoENx%5YqxGs{VBCI zVaDEB4bjKrZaWg;2|?zBUHVE-9rmsXbS^3%+PtZF6PZeyo7P86)#O1!xuO^%SaV$B zQ?JOGfX`ES<0JSbrt6@TK$VZ%d-K+bbVPvEf<@=dl?tmh_o&v(^_J!cCbaNB!kX-E{QBWBVg`oXxtq-YN z#i}3m*GBw$4CsU^OTYQ)mc8YUg?Z10K8=3q2xdXf87y`8Iv3sDT#91Loe6(#QPg8C z6g--(#C}ye_(h(YiT)M3*=Bp=U^~c?pVDs@*DQx#t-cFi%>!UU7u3zsx2TYHLdp^@ z-W}i7)mXjJ7(^{k#w7_yOqJa4S*qOI=-cAwt$3{D zOD{Y}@Xq!6e7I0)5CXexW{K)GZHi`GV;DC%sFzese=~aYU%;!P7iJYBN2b0mPf`mGwfj8a!#_H@aU zfEwgxh3tr>H7Zp{#lC9T~L)@7yC?2BAk2pBA z;ElO2jxRki4~Daz4nE2#9~InAG`P(NoCZ%0$kjM8-#ze^`Zh|jSH2da zf~YpqZ9oX1%+*Z6Z_+yFPPdhg`D#sC#WTX5Q<}Ou%jYsa*P5_!0Z{%Uj&g*X_-$w)X`WU7yO ziD(sC8nPm_@+xKKr&exJ9VxNTP*+pq2L=O`)$Mc-)8LZE=#LAA*5D3}lpBk@Aet0T zr@Cw90i_SUPpkz+cUcGHCQ?j*r{87IUiR@D{-h|ojFNP-m-)SR`D4w|H6}#6*DR#1 zDq7DpDh8$dkr0gu%FVM$GT7GitIlhYgiJLwiB$9;1f!B@DVch#KHR#eu~{^%#GAHYzDud!y#qe?VE%N zco7h!KaxpPNyu+S3?z2@m)t|)$?UNE*=Eij3?$z*NaD7z7=nHJ%;(^Pj_`j7K3o#J zZ?-8%*I!!{TEUqFpHgxacmj+=dv zn)b4IlY6)GX%?zo{N$6^!S=~5W9$_13O~rtdvXXXAgqCgFB-}f(z1j)fbuRkjGS8xuHTZx~=5Kl4P8) zN{+s-YNIK34|9Bv8Iy4oa6XhfQ0QwD^~CZXPqRYSw&uw9(&-~Vghlg!)X5_K^O4cd zVZfb{|EpsI+}G!fm{jjP=WfX3RJU-CjVA5n`<`#D&iC6SxRfD~6FK;@utg2^9;=x{ zO;Vp?c9>q(KI^}5^uWTf80L0GHasT$O6zXOW2X;y*Q(*n9bZ_~7yYH-i~b@&XQdi_ z5n$ZS?nY-a=d|abif|}~(RyxWJSA`>W#`2D?HI+A6utT*(E=n5$0V-3Mxw1-L8?JJ z{hm7&7Z)?Or34hi)<{saz0JI&K^nx+{b_MWn0D3MLWEIyKc_vLfBUZeD%s@twe%si zlhM`Z*~AuP1g_+Sdm=m(JYzcrJ~% zeuur>Q4Jq8RmuV=7DbsqRX=qR*1~At^;sCIO3@+BRJmRV6s%?$8l9sK<-rB71k82L z*!R9FwwZOy6ZgjCX)c&!%NrDf^dNM z5wyK^XlG}!)I|Ly>2K8&fV~TdCqI%et|bYLT5iRk{!c-@-@!@$Ms^>f$b zj0r|HS}`3tw9&W(rTy!_535B!+vZ1Ru4~(GdH)U4-v_A zGx`JGo~?)X0q{(P^1J-ceTKIXQLx|QkLEVYne{zB{XJU-51b5I_*=X81XBZafWIkc zk$C)QZ@n80!ZHodIT*r(X1PBYB8F~8Nv17|FtWnq_MoA;2SbFC_e`hmf{G@7c>4J7 zaXAG+NP%a}JTmfIyi1$U9C%Y63~+gEH0;|nR&cn>=huun`XPR5taF*rz*?}E=R(}{ z`=}q3EDY8XSoGVF>|W74DbGB=`+JDZlDf*VVrHqfTB3%HlFq4c+sEqpH~HLjLQa@b z;!sBE-U<_6Bas>b{?gXXonN3x1qwcY&s_3SQi)+cF5@*mMn2u8P(04U!Xf8_pWAzA z_8X0*-gh21-vdCqn_H91k2i_3Qt2T=VQP5|tSO~O0q_!V-%e%U|M!b;gjxS_PR3zd52#HNtwBJHLI@rQ=F2G-ZeGfW{$lhC*aK-Wmr?2o}UCbG6X zDa(-DXD0!m@87Jr1zM7jng8~e$I)Erzo|8UQ(NijDHisbM@LsGRBHo#J}7Kl9A6x{ zMXwvvJw{`t<~Oh|&aDBHx1fTtwDF}oSpZD@@BWLs&jN zas{1fIL0D;BIMAA@o!y!2TK}_8e*w&S-4II^QSzJVGemE_qZAf`3DbQQ6(lQ{IWO` z3U+UvC3N%DrJCUsmU|%B%-wD5kv_(nz49ET;1TO=2l#|0pVN6jE2XBwV?wweAC247 z1AWoCo!kB3$G=_6HWljlu174PJC^^Tli;6hbpMxyaW)qHtxdAf)=o{U72_sSVlwJ- zs4_hAjx3f?$=G&=mHbfmqZ6Pn`Vy<#1lKmU^aw^j#1 z@NPfFH|=|ZkbD0R7gYQYFNOs-AbzzC^kK}$i|m$Qhz!v*CWfuk0{|C8jtiFH>rREn z#Ux+~99rpQM(voJ|H@{r#2vFp6B5@hA8DYZ0CbA5=)C<^2(*T`!|nTmW5-UEdLdO7Q*c{tNqK$JzJwggX}ow6JfM^YWFqxM1mwPCB8Oa~xMOYH zMIdo~+u?&Z?(5A0P$d1>N4it~VL4OjAAOw+hmuwxSMjA-3fk`M|FoPxySX}Mhf?B8 zc`FUQ{s&;B$9|>opY?pB02RsK2>S2;luZGok~5CRPP<^+fN$AHy;#ACtX9&rywif- zS^tJM)%cz8&0XnwE&CVgdgPA9bNT0Uk;3jTE*_Ilm_+wr*Bv2el=v!?)TYs@xWWxO)!G&1_%S|n=tCfVQ_B0YaxjEN-pb8Vwf)7PQ<0v8 z^en2*7-BB8Nq7=sk#oLS4*SA-S;586fe>FS*ZOOihp(q9rTgD zedcrhQKya1=hK;bF((1|dR_q;HbJLlm?d1+t=p z?*Y0li{(>n-VD6?4#-_vI;G}*%~NgfhPG6a7s)3bi#4eG$zl2jNTH|P<}G!p$u1X- zF{!Ln65wCZ6`kx`ZoPk{A?1NJ_|nj?a&E}pTd%Wfj<+HYfs^rn7L@zMa`Lfy-f=k$ zSUrwezqe5?vHHsdFPl>X)Kh=CDU1J4lX7>QE<|7UmloUMBAD#>ju3jeS~nGKg4ZPhsBidFS_RwKYxkD4@91<{RLWKGJ9$`QJgj?40dgZEDbyL#8qG%@% zXy1#cLlKBq1Bw0TW?lvJzGp5e5p{<wi6J+iPVS7MeSS9i_2w?!MM9NeXU83KU{TKWWcb_xR#{pB;L!)DDe!wBCJVqcK(R$0}qVID? z!O?`ud-2y0oW?z48P2Kli|5$nUwI_w9aXI=v2?NWy+towlgrX_vxnT)qE#O}54Q{m z3$_towJR9?p$#^m>9Y7aOm%6d=HrX)7vI*mZ#mCtPkTug?al9c(D{?6Puf})Vo!<< zt{2EsJ$-Snc}5`&Dds%LmdT4Tt&r1H=MS^h|3&^m&O@b~vL(A(;mv&kZ{MA!sjV(I zB7cU7CHjdkf0d)kq3gQdDfo@fhvw?}b6nJ@kI!Z2;tcFD@C$+}|M5t@lc*AVj!*I* z=Jb-vQ*k3PE!>(@b_RMuFS@fvH%^GUT$}}h=v8-iLq}B(lURBuQv)D_{SzBL{zdYyIU@+&veUxK;vEEKR(Mnq>MHpp!Bd}Tcs631QS@RbiV*Y^fVbzkK z`Pt;w6b~0ib@By_uT!4l^v7z>d7QK1$wyxa;8jarj6o~MGIFZh8)prC9~SP^>TQBQ zF3Uq#2XL;bWeM;`fO2PiWWDy*Cz278LNK84n--`SL0W|x+CK~7O(ilI+b>QvhdG?_}x2z{NOu$)qITL$FtkO+V1oH%ZRCL+6cs7o1l!k)&rrJ0J9@&^#zK z-XOO=qP76^Bv>_7{g`_U-O391L1glo_49XCA1=vuLs63C*}47sU_Ol+OJ$F3q21h- zX8Shf&ZWS=&f##OWd9uhLtK80 zNbMTB?GL;dqgmHVF3re4%D?6)on1XOHy8Pavfm)+#jQ@fiW}7>2L|qu06{p+LWG9< z$}hZSfL$VDxh?nA4X-=DmJ_Z?vXcy1uRG%{_}z@z%BJ9F4h%44X~EWTI#p@r5Z?(BRK5^=>0EShCXyb{CBAo z<=?0wIqAQuA%Ff|*^TbR6XY)vvCN1|rpqZTp#^%el`X7Abfp4pVr_zed{m>INu^!I zX;9}msLGIM9d8-`F2I&Dpr$fjEH`1s4f+a;q*L;9UUNT>Ko{vOfbARHrcwY(5?0o znIn0#skCheXfl9WQiGTXg^1J2&(n3rw(SDWA^BJZadNUD2kH4fFGI@8kzxHxgf^Rw zUHs)E^0jQMiv~^U;vXX)3NnnS>_qrj$Jn(4o}oxnzYAdt*;i(VW1}9W6Y|uz!GFGZ z=Ep+~{tZOhy^s?B4Mh6iTN~MgX9lo%K&U6MWp%waDEsg}^IcMK5GRa%YJOX$?SV>) zy!Q@8N8Jo4eKeP+Hd4uft)wPmUj2PXSt|ti#Ab5t5+or9baTwz8%`~n7%BqZmZ=V{ z&C=sU2jY#j)Ue)%h1S$N7~>&<30Hqn;+e=8&~J_)K!P zjM50*Z*=>@+{fW-VwJ(=NDG2fz^sjzPUids4@5t$s+gGdwH4=G9bf7m43#7y z`g&q`4xH>8_VC}1g;gf^k+Yk3Zbj{Vy}?CDj}76Hw6Z)yRIyESNq^($PZ6KycO*sWdj~!Xi~#5PiCcK9*{276vUbpS zICl$kD^jp49_oFegYt^KKAv=~h7F+CL8lCd?yL)7t}xUV=F&?U#4$x2UO z3w>i$X-DxhyGHb92(q$r`)2@B_P$zN&@p^y?I$~k>5N(u)1BC*3t4f|!o(asTPV7s zZ?xRuaaRo4OdXGfzrQ`UstDT1a36~*d8Y&c+tj#Z?#aB_(*^xTN9}t3z2m&YQR@05i{xLW_oJ#_~0vRZY z{&KM5*~>RTTnpHQmRa+%==Ua6WKyK92I{pJDzB8PEtnp-oG;2acv*F*W4Qh#SR~~q zVYL*F=uE}pe%%Go_E1GCW241BB4=#c)b(vuTdK`Vf;3)s5ePYU5R7RT@K0eg$qEl) zFw|<fERrEUhD@UtzL$O0dS)i#>`9s<^}#<$=9@CyFPvrll6yn zyI~9S39Bg2*zgN{26^@E0oL>F)FBT6aBlARuw0CLScqc9EQP#&8nTZ&tiCj8c4&Ru zmaZI_q-GbuUk3N2OO4gLxCm5SAPzmImPtA2=^Bn8HDY2xX-U~XAPpQYPPQ%gP{$CG z=(kQH0-m1^Qtl8mogC6){e$X?O>j#jIht>Wx5eI8eo5vtU>Rv^d2$}@C9Zu#%{^!e z#mxvFtX4}RCl?)eKT9f|#u$(A@Q--&a(laWKQ7?Zzb?N|opK#5OBEzV{5}@q(=i^p z1VxN!~EkEd(`k98rnEjQ8#B^$uukPY; zb|WQ9j%GvBytH`#+YR-fX-Lw{of(?xe~3d`NWN;5uLm<@0=I~pcZ{lyhg0d(HY01& zLqpBrfX|TVu7L-q{u+hEM{Hs4)2=Bz3|+0Oc4=~$$fnTom)S$24viU)Jlv6Zv2+Qp zbYl)B%!bP)%7T)sX#FoMKSO}0e493fd6~T82<=b*2#CZ<=^)^Qv7E2>ww4eAy9v~B z89|)s4rc>?yS~a}IOGY(4Gu^K_*%Bw;tiI#_PwLo5+>T~;PvsmqKybi$>U=NW3uz3 z21sj8vb@lDTkdLcrFG9uR@p-dX)Yij_d0zUA3XD@h|yD}gm>u>lkBKU@D2<#TIzbo z6W+JIDOn=}4W^8^7m5|^8PJv#DoUuZ5p~wPs#+L6JMXtPLrvvBpcKTaDGG+eT+Bh) z+5j*itJeTp%OT^AS}e1iRvmMd&EDV}YSq)KOMmftN~3;+zb^ZE5LyGbG+31DG%5R> zP?b-fPF?|_@)gr#STR&kMV_!Ht@on6K2(8!RRJQLbI-kE)+m~HM_ zIe<8TmXGJvC?E}nO)I6{Q)n@#qrJGpfk5=`jAyOM?3sCU-gtb=(_q!{`u>NdVir9l zz@Vp+&L(B}_fwwlg9`is&pu04=y3?(_`*BPm3}#S+Z~D2qaQw*w0l!i?}jf4Adlg} zDyYxMgiO?~LC-EHQ{^xT3ox)Ftl!UdaE$7Yy_IEoY3f&DbD|J|o81J+3DC|vkU@|D zS``V#?zO^OFJ>0e5hROsP66o?WBV8$GwrUz?69LbisHuzlP(#Q1)?_0wEu^koWh{` zg0$4dO7Fq#NQ~Ox8M2j>?rbpzjnxA$^aqntBd3YT`sq~| z1n%q((bXp7D)dn-j1Gu-z!5V1Xr4<*iGa<#^CFD+)MFQjqjV8-oeWb=^bfH`z4xyt zh_hlINA#FsH?9*17b~o--6bt`oE&Nb&X;qqS1+pCmdnNj=#w`6rcGz2`grD3E`4F* z=$S_Wwyc`3vtq#Qbm!ri#SCl!m}c$4SW2_sp0LrbKgp)1>)-P*#5$kD^rAHTf|d@` z87BiF(U~VFuMFTjC)UH9t#;MvabAWdc?6$^kA-sCnekH3eO zox0rg#?=zy6pQP(-c<+6Vo6duTrhJztzvrM@l`{_@-Zd)+~W9TWcR4i^kz(*nAB$I!A^3R-2s;mkU zq>KrKo0j1HU99+m+)1w&b=54;M+L+;@y0o{W`6@jX7rd(rX^yTC$n+p?$GPj|^m6ZI*i4XCnjT4LawQEczJHzob{lgnd zZq5(euQX*Ds?qmgL6s1StUdza+c(37l zAqD;Yy;{NrKZ!cY02cDyBdDrbZjWOj*)VAk*Q}l~F$!o?cGYGCA z8JsSqwR_I{+e?UJi!P;$WQUL%USOajgeg7h9+JrQ)1|EC2?FQc+PFHn) zT4s_#JB3>7l(1c>4p;RZ7Z9}?3>RhWb4l`BG5Vg(V?SG6m|EY5pdobm(-#M+PS(>; z^pl!~Tb>}pcpCc8#0m^4t1r44B8{9MOWl9D-Lp&QGu=u^GA-Un*dOOf#O~E6~zO(SDc6Pr1^7)DJZN|s( z(Bc03sD;)Nr7Ts{bsA-sI=fJ z47S}RFx|NnW9-t_p)PGF{?SV#s4A+WXsd!^8@vk+$sDG^aXgELR@=L_sfy^G`vqQMw!H+J0cN2JY zLj+@ZN;9|r%BzRQyYPMHiEg6cDEr}#E> zA;!koR<1H?!Mcs}M+-Qsx8j)MWVHBM37#k>-+aq{PHx zQvO7Demv&-NcND)_^^zbOg2b#aTcfo>1PG3qkCPo|$p(&C}1dB{vG=_Qp_ zM^3BEER@Z`ssg9yjZwhvt`2J6uVNRVTwg<5rz7n~l!b?!hE6W_Rg)nVnEVLpTNcRC z#;vDvZS}_&Qws6jH=V7i_!9HyZuXcCgTWqd!kv(*I$2yP!=VW=1xLBy?K^A>VXaFi z$neO`=NTp@U4iO?HNhaIT+9hj&ksTRQK3ruLs><_alsv@Zy>F=t(4VXZ#}(8>*2B1g=Q^T4XV@TNWIDOxy$3n@oVgozW% zZpo`t^4LwVF2Di)(ANie{*;+*VR9p&Y$MsYCep6dF3y*e!kKiNzP)C8^B6!pN*vL$ zIC00yv{eo<=chcG7M71U`>vF|j>j>kAa~5{;$cq+KC!CICU%7s%XH0d^5tie~VU5*-S;7d45d*B(T2y9w^ytMRXPir*-dtygep)E|K(DZCwEh!8Ou=@+DCv zg6SsZ= zq=SP3^#a7WRTy3>;4uT=wmwVF5*CQ5;@Vk%cEU`I+F%KG6C8DNHeFGT=#`;XJGN?; zVOyaW1WsYg7J zlPJC2A#eKGjpit^_SlAVxp`+_1jQtFmw8mallzvkChZpEpt#u1vSK|EM`}5aV+p@M zwXPWDYXA{GD%Pr5^@jq&3no}kT@juPPfHP&%KlK_5jDCsI_Mxbm|VWJUEfbntdhau z*6&>sP!uPSKkfK#qjoTbMEt7&IrN-$8B40GNOobt17AqMj^%RQnk1r5X7O@~a~sEs z%QV!r(2KegwfSb%c^_C{DEr_XjPo!=%xM##!=&6 zF^*;j*#9r7CZ2FfT!|FTYdx5lnp*M(^H%iqkvin#ZxXp~_xef_!%^$Wf(T=bHt{_x zI!W+W4wH2?#m?BtFv`*7n!6SGeKXt$dWi`i83fSYny8GpEwlb45;1~@HMQEmV&wKG zwyp1xy;L4C^}Km?x~Kv51gUtq5Eff~9JcAjzPixb?OzoY-b+ZdH!R^X^r8^wo!ZT% zv$twauy7hOB^c(+KF{3f)e#dJiwL0LT7jLcqUHH$M#)HRtB>e>9X$aTFP!4(V%IbG zd&bf07TU;?M!o2~bYmM2t2%WaDqRTi|9zaWmb84u)Iyx?dt5kniS~?x-OeLEa8HBP zgI8=}ZBJOV&3=(fP}VAWYzAAGjRf{@r`CIxhLyudn8a9@f&;O9tE*apY4&8 z`{cof8q^_+=G*}N-*iTN>-|@q5pLq0j8+ReoXI=`vb~w>G6Dp!V*k6Pk=ex7pd`ke zk55{Atr!BnQcY2{!3aKIzlTx!-o|!T`}?_;z@J+qZ?CL0{-!n(15jdrGEE4)s+{)P zR=1X)EUiS%wAKKUsn1FhTLL}Zc--dakIc9vE{S2Q>P7LYJ?_`NjyM>UUQ4R4t{E*Q zYx1|fy5O;`V#ut$dT|^N)I_L>h#lm8>TNKSzJ{;p;yGAVP;Kqbr-$sV&mtNnKZ!i~ zL4T#b3qpg3({2fT2E2$Er~=0Z~c3F5@8r_?vwlxD%0$)$8O$ zjv6KHeNU`otWu6&Sn?c0E~-Z3KU8**jJAio@Ipot`+NfLFp(^T|xSm4_mOi=Ow*^3;mK>60n^pk;FC2=)qin3b*zU}c# z33&LvXB-+;7i}b_H7CA(Y4JmCmD*?6k*neztBZ3z?IR8Ad2~ZB8Fpz^M^_#3Q$O29 zx5FErzLvfkfv7rVCzdZ*v#?JF3SVxb!`w?;XbB6>ld@`1brS+(2CVRXz;SB9u=%E2 zIgo6&bwn1A1=hE{?u@#JZ-|VyFo`DL51IS3wutfZa(@_+{>z`V95+-oD z=%8*Zp@CF$$sMN}%MrAF|HhqOq)_8|I>Jw!Qo`>KA959+&-Z5!u|J@u5gAx$wZ47b zwbbxj;0x{Uket`OH++|DRs9a5&Zz0DCm6EP9HrhmcI0kc@i#N;SF(og00VO;pf^Hl zszulE7p259TVgExwOc$!!UWU&gr@ttGY}JK)c1z}I*VdTWYv510bbT9e!6X=?4Tpq zRRRbw?)z$XYR;nnlF6>mCifHI^efoMV{ZaFtsw4K>5u+ExMKF!p&(QT%_a)jl}++0 zd}efZRg*0ESE>mxZ#kS`|5cR)3AdufU0)pz;%H;-heiO` z??tfKdHe_2ksBrhXlbX@(tVEAA|=jA#ptR(MICM5ytH97bFZtC0-9aEqUW5R)B5o9 z3P_Zckt2!RcBZWWxEr0I`shI|=c1J@U~2BS{&IV_J|HnOZuNY*e9vl;WZ*uKA6G=| zkUc$7wVzhP*%RNVRhtFzMk){z2_J~<>(q<8XoK|zJD1K!<)E(ifAbz`KJstNb? zE9zq@ohiqHHn(Rx^sgp0F~rv1GQxbFrUx*c>p8>|HE`PZ;dYT(CQbHNTQ5mZF{V_m zjgoo26FADy{w-{?C!+ldEz+rjfiP@SK2@{(7*3r3Fe%F-0ra8hf{L?P3-a9ar5si3 zjy6!UuZH?`?c@p)J?ODc{gWOENDwl8`_@wZ8h7}23A@2HwgYZalKNs3S9hUDwKIu-r=6Tu`j>Vh_6^;yYRA|-+_%6{tS!=U z@Gp=@n9X5iSXu6TNujLA5JCeCP1|jcMQ3+;zgI>#>UJ5Q;S)Z%GuI|@=yx3g$2Nv< zcdQXoowq`_1JvB$j?Q6gT5JH`qCkj%dgs zRo1=nE&@>p@+|GGFP@#!;h2Jx;}-(gW%=P-)*nP(-+&zoh$62)TSBXJ^$kXF(MO2S z$DZ(K?NZOa;7+6pzu-EH{P@&cIn5Q3seilNOwpk|>wopwn zt2WwRWeqgh8??4CZ*mqSX@8c`PN5eba~U4zMS1!~cjSSw-}u|q7{v~|l$ub-A;s>; zR`GKZ^qr~I(Sn|CGYxCC(M_|kx}mK<)l=xq`aa$4^vr!lz-rKC;wd%F(Yb}25b3U7iRd*%zLC$4y2fs6f)al;Cki)4ZK%x*sq>e(2mkCL+U z&LujRb(=`v4d+&=~vHhTp*Xl z@_|v)Doxv3#FzPp45}$p_F6J^;%ZXHTtlNed_ZW1w?bQJzfV(VL!Z?L*bgtOI^kx77FJ><$rq$5GF0 z#BO=8`>%e`#>m$>RO$kxqk~LJd&8|X;k$LXAhX7+kNpu6qajutZ0fVVv7@tt0tLpVftBim*BT=Qi8{ zNCGXC5M9CQdZ!?9+KuvRyk4y#{SbK7>lxYabyB9wy z*i;-d*@O-i?ZU2r_rWHq#A?Xo!@TuoPw}sOo0UWs22y%2*LlzW^$vt=F$d8zwhp-)cHnUl2G##O==BlN2QGEQxF9 z7`-?#e`XhUMliCJR^MrR1%LgO+LF1gE7oGRYRga=cj2O~4$RRq(ZYY)IWg+x^FhMu zrS(>WjTT69e%JZGj|X)sb$c-vaVjRzB}U%9PD%wz_KVtebAThN4g%<0pIaw<)6*(`kCn%Bw?J8vm-M;3UnvJ!??*YSjFx+umeb) zN6nOl-?9BMT2EWLd(c4anz55~KXei^k_R{^LcF#u7>?wzX6tiPD;R=$pHT_+{LUHG zk-o`S$kp+QSo|#RI7Sbq?;!gEbPH!sD>-4(U>7tpS9XlN%fD0dIy7N1v*6*C0Le6c z1rbbY^#}O@-H5A2LCQZi8!mdg-k5DlMP}RVo(hGC*#6a*;cM;#fdfcciTYjnMMCQd zq|O_X+%WGCYzCO}*XL3br0kEUGMoqE=iTdFh-Wr_(P8#8O#PbG;#XD%7Jw~r78AHW zkvpUZ)RBD6z|3l3b^Pg)s2h@PYIj{AI=_d655Rc+yBgBjupb_Vnf^8L2!*(N;$Og{ z7r2|ApzU(I#tHMEcI6nG*>8>)@}*BVRm@E3%`Yvsh?NB1O_O86s7F z4wM*BioRT&8u26+TDEg#$*R;~PLw7_W}6qcPJ$P?4{~H1t6Z<9WY?GPN!{^|2(?pA z)mLp#;*R_8CK@g+Nu%dXGu7s`os}1Sn|t_~2(<413&bN}q7eH>#G{Vc>V&d1es5I& z!&m`j_Bg8oaLOytJt)Tksi>SF1Np`_2l;0c0+>O7mALLlNWaeyTo(^~bzQ`7J7dEzAEOR9n~dpPBk?wRJDgnT4_m192}fg+RGGTNiUUj0zEJv-qcq^daG!}{#OD4R#_@D zfl!wD#HH$5yGRh#!okErYtmw>!-u`)mfSJYG6VHSk38fh8V}p>J{=@>v{%!^P*O?l z+Xhfa`}!3p?T*OnD0ifrO|H%P@ZE- z)1HzxvTqXXY8hpQmKugT6we}@+raH3`xlZ-BlIJ=%&#wfcZbUz+dt+i)@zXw){Y3& znsa+S8V`9&lAnLF5$bBv*sCtz+R9-lJl0M`dDh+1R~lo2hg=EFBgU7X!CQ?FSaV7Y z#lPnRlv>uWlv;Vd6poO8BO3tm<$?IWkqrPzVqb{R|Hf)@pd+!7K$+j1Hxad_E_oP% zsAQkf?y_leG~S~l9?)Z00L+m!S=D-uxX!2wP;Jc}qe`UTxMRUUA;eIDBgyMAQu|W_ zMl6^1f8aNAIuJ>7ho|5cX(_8ayKNKFd?n?pm;(Xd4027M96Y}E-8bK8zoQ?Z?8m;( z{`yl2K!nFT-<6N^vs~VC-mAu+_LfEV%GT*`TrZyD6@E*<25El8lt%VA0C))V2}3q{dAcx<$+2vB=xdN?_Iv{ITch^NVFU%KIH5Kw6vJ{`G(xq zrBK=^l|iYkvDu~^B!WrTm9@qGp7sM&7=OS$Ug9}5LnW~2SBA7bI<`K3Xny&JP$i#> z4}8+l3M!H-xbZ`wjHI&>drt{!MF5B}`{%whHUIz!Odg$SZ}|J48=!aFq;K~DKRSH% zu761at%$i=ScY>f4Hl_mWxf@cC2A|$MIfQg3@ zI5~a@v&Ma5u?gTRy0>W8Q5tkETRM@*L<-EiK)8bBmyADlzi2+}x|7f$EXKq5Z+LANV|ULWJiu zj?DhQ_TD@!34PuBuGL!EWY%gj$I8meoN~&M%F@cIGSi$$Nlg(=5oe%L8=T5{Bs1rM zEJ1Oi9LtGR1O=5!1r-q$Q31slTYK%@-uvC>+3$0`=RD`RuERfwdMWyw?%#di-_Q5! zqnoyJ=P$x6(nkyhI>v{A(vkA~NJYNi9HNUrfsK6JJQN8JZg3eO>KW`5g|Gi>AX6=4 z=DbjOOXtIlTBV4&`}gchXxJGikrW{{e4VQbMwYkk+z3MN-pzN*--!|^tz#NTuukTEnz0w>y{PBM|%gftQEV~E)a|Zv<8C-mi zv|jXI_-}g#2aB*tA*&+nAQu+2+7nJ&laS&BWrK1PukQ~LMncR8{5jY@Lj#{)!y&}G z;wm5j%_fX7Z{ARbzkOc3T8SMaqto9T%~d6mojjW^^K+hUdsPHjoG4_Kv5&9fMSN17 zk)6+1&+m$)%7;#F6#RcalL+%6Gi4XKba~m9%;zxujl0I+&l4_ zRyx_1Po;e;kE3Fl)rVFD^&)q7y$fN9C?mQ`VCC}iUp${Qv_&e?)6T*53vOrAFNc8^ zkc;1U*^S$d8uLq7Jv?iv%xSox@9J)tn@{duM`L@3GC!^QfbxoJTJ3j>lhdkvo-cA+ zRZo=Xz`{94FKP0ms*~y+0>H$;lxcIJ7L8L5!d}t(Qm6o z-tzq-6E5`=Y*tk!>zH<8NoUgA^)GeIU7f(zts11*;T=!Y)fVzB>UaqhH67131`LP* zL9h<|Zvq0WHzKYMx<~txgHS9(+22|fU|X50ljViyM7*2=QSQ9cONJK(AFh=ZAEDwj z{70ThCmu=$`zN6#CbMy#cD#C(AlSe;#mxqU4Lfy9J8WkZw_SxoyYez?BAK>}`BQf38c4`>iR})kml)jhz*O$TH5Z`8 z&gSX~k9Y4eA^Wo`QN^=}aGX#d67s<6dwpV<5-=vv+`9f`=iUV!M%3{iC?!r+6x^QI z4Xdg!iE5DISu8qUt17`xoJC zR^u)by#%J*%~piaQ`23z5m$pa&Dq=K?4-|rvj;b}_7|j%d+$C%Wih;8tIq8Y>-BAT za`i7PB_$2HG7GSXr6gPr7*MHrr{^IODb3%LGsrXQqf_{U7iyv{&hPL25?BG?yFv_9 z)+kC%4D=HVXz!^(vc072R(Era7LCcfXNr0QY+VPmU7{~Jfa|K;_9{g<>FeoE{l(QDysgmD z6-9yRA=yLz8hL|Po=R)giNC7KzR`bx)sYV9)DD%_%8Y(ZobK63IA4UOToao0Y`p#= zHl&yE#0nEK_I7TKqXhU$l@0=YN?lZ6ef9n7eLNaF2N|AJBK3aO;p+Er)7f&6_Ons4@T?Z{HqQhKBD&`yQYo)40SLL6 ziR1|gaa2fk^L(gyNaxj-HGtB#qBVdLOB8-zn|+e&vG~@cBM=d%A&+{Ujg>ouV^@DN zSUnk(%|2lz5?~S2^9tpmwad3h-o6?<%w4lcxhXw(Vv$vTD~7kZl(s{$F)pR%dKydj z0c5K*cFiS43jZGqu@+xMDq=JLFw6?}g7?*{{znekM>zDaCLnDmv5gxLz4GhWI4?HDX_0m~tjwoExGT zpr)MSHBb+WO4sZ~?ni&O!5iU|^20E-F<0o5lrT}m4 zk@Z%81t%Sm&#yZ9hlfyJbXtG@@rVB*SF3??hUs0z6?CVElq=)?0@2!0Y0}1~88?<|4>@TWG`4E_8M0^hWc+ z+l4xQtj?0@7FTFa-utTwQ}0k_^WH%sjFQt&7^U(2io#0u8$JPh=KnDGb`+g0okie@ zkKMgPGU+IW&p-Nlzb~JFS8ntE;U{q;>hapC@+jhgZ|=@ARavIx_5_iux4Heu0oQ0C z^M8Y$bicAN)cq2tp=C6F;w9d8Xa-X0I!e*fasgL7GkfnWrwT)fT(^1YdZ8iFtV#~3 z<;}m|FOns!G<8gukG2QY;Xih>TMenfZ|gQ6)_K#jG3BPM4{5aX-GWJU9WPls_M}5t zy7T?oSt6zO1Pa4!5eE&K1}RvPd?8VfMQGd3!PJn8OABp|C7)CA!<*jZM$(Vwv!T_( z%hT_iy<{K%DgBVEgOrM2h((sc0X`R>4L%k&Ybdom*xx%EkKyh2J_d3bqfP<3Ym&Va z^qwQyYn!Xv$#e!&M!ThO58-9mN}(#`%=oG-==Ff*xOFU4aOHmET(R`?uG71Ia3P@H z&V{qM0;ky7xcX6?W2HtJzK;`|XcpQ`&e~Xip1{XnW_~p^Lb=iBKC9d-bsx2AGzN~ORa5`Yw#?vRG^McQl(%!~*;@KIo{{OfOOsq`Tm+qD7mJ$uZKEFltbmwjh)2u~l$YusE&eCJfs-8?rT?IS zknr&Q`_%g$h5AI#6LPStKD$p&psVqxSC4{_c4KMW<&E%1LBN^5B2ua0+vfBA1nHg0A{D#}$d&_H}vr70ix)4ka1M{3%! zrXB*UpML$A=&J%-Eu?)%tkl*6lF=SFxdNdZ@%TSohnvqWiLS$M|97s#tqrF)Z3=T0 zbnOefxBooep)b*@65j|qSP3D+F7OvcRslA!XA36)@D8UbA0F=rtLi(S5A^W93@`Aj z{jY^8shn>fbeNs5J(awj_sYoj)9)Y(xHw-ycl(JV+{D7NlHjgxF~jP`YOai!-mF%O zsgi`2Yi--1sVn8h)9vNHk~_Y?;qH~3ce%8ct3kofA%>DF%nZ`Q;e*$vw}rV)FwS)C zyou70MNKasSdk>(;5t@Khj*E*e!zdp`eObjCRfVrwJL4;S{6%PHC&aN7^vJtoTIhn zzk5Gv8uOG7@9#5p6ANX~*ZtAM*jyxIRj93uz)|AIfz4VlK-Z^Xp$R zXPKFrz4wIGfQPLmm>L+aT<4ldAgD_9)J7=>oh+0fcNpJXmt^>lwzbZB23J)|#(yht zb!l?Em@=^#Pc7eDu;Tj2&fwznv)qRBUdEK2lSu?-{qn}oQx3I2)w$7XPnYvzuJ)VC zeJoBp5M3`jpDC2<*s6x1>F#?Md))MI6@+m8AQK-M5npN4-=b@dd)82M-@6ku@|a5N z^)aQd)R$Pd^f0MUA*Co5op7s&CJjxJvzey)X@k-*C#bMT8OdCm)l+04qhYUSI-TXR027&VvqMRew#4YgDgm9v6mqHlv#KOg2ZYM z7gXb-2lFyKb`2BSUTLXYz^L0V+=zMVll9AhN%qG$jYcaPlH4MhQ&bv7ysyyj5xuW4 z`{|A86>fvGC%%$8&QN5dyVIHO2piNj>VBHXG&%<4jmI8oA#n#X7~zR2 z3ZBVY0PG}v>3Xu8^M?0Fy*q>LtB)_015cIVR6RXz>xhc_zy4Go+K9v&BeKz+D)xKk z1%52rH2s{FT~w+N42#5FOt`dFe9RDh|FE+6X!DEKx{9G0?piA3yK4fjz*V_xQ@s;_ z3kma6QYo_Aim4aJuRF3&+?PF~tOr zREOE=&tbiU+a3z&*$@Fvirt#b#P=pC{!5rrh+~UU>GHS{1!fZ*&+daMnd}0r3A3wD z2beEmC-*KRQ^Wtz3D}hXsT06I*Eak^o}Fr2k7w3=OD%FykV_r4wn5q79Hn@|o;@bg6KOq#u{FI9b2;}GC))e2 zuGqtuCY6jp=21;S#2|~X@Vu1kyz-T{6uj=iuP9D=0xPlhCH|t!KA7|hPvp6*o$#Mb zQ*vJsFg(_LkyUl}FAfy=Gy@c-W?8~YG+RECr_0m-i3^J$CX4mp0JMwr~b(Cy!~5_M@aljj;C4c&m52PC*?nLJkg~t zrd4Q+n%>@y6!$2P2ee$@zjz-%(mDz$aBn!2O~sC=(^C$$TcK% z=QXpC-IR1s9$6Cqpl|Ed|4filPb%0${IDT*gEBpK0J{^SOu1ShF_G0v4&w8{e zl>K%}$8JS9@Z|K-+ZiOU7NC@TByNSD_S{pou-?kk>Wr&<)W`xLdBu>cX${k7)jyCvWK{nG;QGq{fPws_j6h5D;D8M0tQ0(Cp|#w@mBiZu;5e?7987HE`n+K81AoJ zgK2ruS{NTv`|~HPKT;kSoC2N&9U|{a8g`4C%c$C+LlsksxKZXNJ*!(ddnP9ASqPj~ zIl`*o|AEp{-wSNt_;5GvopVr3J1=D$6Z}bzJdDj)9IYJq@JeE<_9MwXdeW#yPz|eE znG)CVtVP;6KqHB~)UiRJR?p5xhWlyE7kFIxoXyQ_A2U zI5Zb754vR_$eQWaNyMcABk6XkPhs`oXG2ryOylqwt_-&)9o;0qz@F8rtEMcUcZWft zj+V}5CoPrbMW)HBzgjf@r4W_%e3jI`>pu3WqmE)`UW|#3)Es^>I}H(WwZu&*93Lw< z()o?<{pHxDei=>ihQTibQYIgrN8&%5N-5wyG+#;;Wo1fx9px2n<8tGUK`V{PJS=5^ zj$MiW#lI8bn`KH~cw4q>eB*8G1W9G`%-9EFJ$`Qsm@-*O{$!46&jG9Mfa~A6eIo~D z>bpV_jLa$VJIsN48-@-)YbA;8V=H%{qd-$!gLG0bU^Iu(|2z{pnT&B}*jj`ucGql&O0m+XP~S9^ zNNAj6msC!gbbImhK^g+Isqb*6fmKiixV!|_t@W5k5qrJbN&$unGtPCzG8U83jh2v% z*I3xqkijWEtxb%VtMyqUdI5B$@fD(4NpWZF+qs)eY}Gvfc*p`QypF!Eey^rD`WJgK z(H$ySMF>^3s)&9*!zE>u#0EVPf6+#+KKoMo+)BhtwP$_cz}p!|@5EwxMW2L=@DAOA zIf&FMCVB=oVx1Y=F}yUdOMK!}p*46#qwp-K7`wARYw7H451Js~XUTK-m*u*0JSQE< zqb5y0VaT4M^hL>dM&qEpWSM9F@Q8_fA+Rv}VNQEysD-=3&`OH~Uc`#XKPqMnC|S^s zSo}Pp2XLDfaz8t>piiMPGu1L9Ny!gG#T+2sP|BT4(CSkKcAn=i#n=P<9fuDGP3Jzn zy3KieBiDU}r2S491|A%(TT)%@1L|}15GwGNO&yHIGk^`XT%5~7%vE9L(l0EDwqJ(y z2rX(0XOSv0EsEId-Yej+4t{1?I!)h1`+aE}*#^QIt*R-H{T?5txM+dH?m3qjI|E~D zoLxY(@vk`9j4dY_0lR}b*H-S}YNo%AD*ijx@v#Ps=oKmQIt{_+fKU7+1oAIq&V5f%!)0*77&R#^4m74RuW572m+ z&yCp}6Bvo;=lgDB$M-@Ia_^36mng4XJDVvzU@QeNgh1X1mMImEcyvkg1pTc*hp1s9 zHWDr=zmJ>je?WUm4Jvmh02Gip(7Jt6)|-_)8RjujN=xFITz|(H>xicI*0goM*xRbU zq^pUPyG;GW3xEO{bxlfQP3)n28fZ2{Bn3Ey(hopL%xm1LYHj8d15J5B-<9mS5vfq^ zh!+x{Bf5!1IUjZ=$Y^occ`_bMv#J=_aHGNvp=A7O>V9AwBHT>i9?$I98wnS!Vy()Z zm^3K0gxcU`N%)eJ(nn~Vr1cFe;077~-YrWB+KnqYY~9~CtWIXQ4RXI5pvhkHGs{6K zNMXjAdC%)3Hl3fcxrX(IdjoV%7Ui^?uoDTt(*hgF(D_o>E#t0cYs(Djoa$=c%`csu ze&U+!yM^?1D(imUjp^;X&UyPR-+{!Y9fZZdz9n_I&_&(*auA4{e)`3ft*YsZ7wm6? zVOV{y>-igFe55FOwx`p+6OE#!Oe`8bJg(QgKvN}7*n*F?)`ATUe>LG#q0lfEHUl}O zb@@rB^Aw42wd`f-*@rh=7iFe+aP9=G$xz9!aGTnpNFx@SIP8Lg2khz|^vXbOL%b>C-ApmI#vse&t{h-&>hn~D# zG62;LwvM!U#OGwBTgtVlZ__-)z{+>oOAo=-mKaWpd+7tQVH`d}1=;dt(b?$x*X7+BGnICA4S>U>E-$cZH{i8!fe7I*iGUm} z=KwpDLwAzAsVcf|X|#%s!ix%x&V#y)%2Hlh3HfgJYIqyMf)Q{dR=2h6p}!^iDb}(% zzw&6ZWrw;I!qLABg*q#IZBd#tjJP7Gw-BJSz3s#+7HctB3DPp2XsLU=gJgg_^fh=N!*=mx$!|LOx<|nZf-8)M;!1s_dw`0d0G9Nf1T!Pc$y3?B z;QpKW&PLz}Ap=*k!B2>`+vTM1XIaw~2B^41F0P8eNtS3da|Lbo8BoFH=fv0IhGWL9 z*B1Q29?r;iL9A{2z4Be?-jFt3@ka9r(t)uCzU|ZefEvW=Dm~-dy@;BSHyW zC;5oB6(~nCJbKf20%EZ8MfeTaW+8^`Mw6-w0c$zsw`;HNH=YK5Ml&9&VHHY@a@x|s z`TqX$kYKId@9>c!y92f%e9Ts=!53P`%Lqd;q{yby*dw6`LBet>vl&IV!xo3nb5vUy z0DP!+k2=~J5k4ErI)9MhNwQ?{Q=so7_g!0A9;^(2)|9{Oy=fT3UJM{Q+LG*{U!LM} z$N_lU%7z2TE}=AN*6SddJ~As6pB&{NxTlfaI>=!-hs*9h9~%~|l=fm|E6tQn>A#+* zJGA?`tcNO?lR4Ejh4y1v$n0tx?$7Xtr7~>EDoi@PYGYbZl?ikmS=5ngbA~CJ6zd4h zPO4T3Chgi8zVnNmm5tWES)}@)Ra6(cxev;WF!q#zb+xu!5=AYfB4)aYDI6{n)|;#8 zj?I=nzaB*0CS6mPPaA*Q2%i2G-|Lbtp`q7#5Fe<$>Mj{(s@1D5Kk=ceIeBuq21-YON*rQKJwUVZ8*^aR$SUfxs@5>h!dR! zx;XS{9>h_DcPDal&i9MRPF~{*gTb)Mc^G&YXi#_Em|zVGkZU>cVSuaUys8`-eQXTG z%mSJfFDBM$^7Nvh`ZGjuobV<8fv!DB9A-gZGcDD2-LZfz*m z9dd4btYtV@kSARJ+IO7T8nO^WE;jC9UKD%Un4!n@jbKDVt%_3-nUl1Ww?RgT=?d(q z-LrfYz{9Y1)o@s%Aujj^c(paP-N`JqkwMtp&u6-51r(&7h3lL{w0#4~zk}=K|CUId z%;={%s!_IKJLPt}-Voe%Qsis{^yK!mr1>O>K=#WFc8Zdw*xe&PMF1Hy9{STi`uPiF z*JX$cwq$G${bk)f(+?c6GEpyckf?_FXKcUKIqP1{tH5=4wWpNs9vv6i_sXp&$X7{e ziqS;H|G$Qg!6Cm)KcKAtFz^=rA@!A_D4P7$0QuER)Xt>yMYDFxogYbh+}E+qRa?Ep z)_FA6|Kjl=OO&_YIkSAf_$+j0=uGd-iB~YuT)oG5kgWJs<-higoemHAjzS8buC7e_ z^%+EQ#4sQ=Ne_vIJuRsl4AmvKZ5-M8kRdTLd7myxgS_%=DcPA)d#05`s+?hFYGzJYpp3g_8vpRQB;g(i(0~M*OzV(y;FmIwFc{h&a&2h z_3pR*YQEMuZtzPM;I7u4?e)?>O^unkU;lf)u|eKk6N&)z1sEY~SGE8>jf`l>N6?U3 z4yPU$%-2Vr?< znN$~pFY+W$?3T>lS@(E^dLLtQ9bnrv_^o;Ze#c9>U#rN}yzx`g?`LcuMqpK@5wkTz z?<+`@<$k?Qesv*-`l{p9=PTb9Sk&b;77XE3H|8UTVPf{DeOH)a)+)l~P=cQMJ`pkHu~+{GVZxTou@}6jLbVt63l2| zqK={h3JQpT3^uu|(Bi<#t80D!x$a|2 zZ{(_@OO7sJD2W+qp%T+o@b1j>^bHH?bb&p_6~1nBsGQR9ipX zfd(tDmW6lMe_rXture-zoZ&r~EYX$qJz!c29Lpk79A<%*#mk$3RYwPT+7FarWhg>I z{L!EytUm&;>RF3bz)}Yl%V@Tw?*Zg{JLo4DE6ejk9H`pz=PHzqhD!hz-H|Bf#g4>$ z`Nt&x+m*DI@6C=^$4Rt{r0h zIqz{tRzlTAtr$!q_-H^SYcY%7;8?ffR>S@jyII*Qsp5EY zqX7Oc!+q9G0?+j)`q?%7Q7%>9qGw4 zVE>%&GG(A_)_)iMm|q(#tYbtAI7iQSXx@3uNRzw|azbH(vVbsab8^UecA~7Qz%tcw zG0+FN*w8BYSgpE{wiFJyG53Dpik6jDx6zSR0kh%M>N0MZb2lSZXJ)~L1DaWk5zdNXKUB)FdwKzx@>_MZ`avD3NvQL~!#diR zp`#)EcYp6266+_(5h4^2FY!0>ja2X^(~X_F}C?wf8}HlMoBA&h2Dm=Mj&YIVh0pIP1@HAK}rO7l`mug`u*A2cm%H-3J#eU~??UbGPOF0f zz+Q3N5gzti=_MdI2OO>Hygd@J%}Z0153S^dd`j#8ggr5u`(UZ~3#hj$dSra;Y0~YS z;`V3E#YD{MAsIbD1-g9ImUUXbr8RwC5qenqvok}uA=)RZOoOjq5cC#frcA!->6^a~ z=&^EwKChXo6x1bDN0vrIHS$#nCVK90iTYm|)y#8V`{;tZbQpXyxmBKSVt7Zs$8qoH z$fZPh0O$9VzP}E=i+7D0>4PB?@4z_sej$*)ynQr0kQ|tZR{%~qXRu*jd$(f+XGkcA z6R`@A&pfYbA>VPyu};0LatBM7M<$?Vg$bCOnE>Nh?Xv6nKJX)vE|xXEYEVryS%&c!@-cV7S3&0+QA%7r37Ha3480i4Cq|EdZ@tFSYqi*5SEj^S^p+)I za>*(2BVk_lvYO`s-Ww{)Q{i0t{xY6FaL?`e+|AX*p-SJG09-bC)Q37c;HVVbs#h)Z zXJVYpo9J+w-2-;bf0uYkbx#v|qrj}Cmt^t`V!|M^mB4;oEG2y|WpF>EaVhw@@QqwE zp;o(8{=R4$Y!h9)*QP;Vi#A?t`i<^T%89&r&2*(8OL)nhw;rI^3z7VH+C8B&QyW)b zE8tAp3SV0xox{xMtc6y=IlT~-$HXd`Snl-HF5_rc3IcWp*o%b$wfQjO0K=7@B4yuLdsLmK%Lm}MC+T|qV= zN1R!ZvSI)|;nnGrqLo|DbLb7LrpYjm*e%a{*-W`3Su)=r0-xK_hQp5tE3Yhm(=sfD z&D*rTfU?u@YkR?wz4=KJB5Luz2S44lwN$O<(-cx?4IsU_kS)TSU`eKlv2f97*<>lE zx3>QnXE73q%Ii(pxiR|Xqt3IO4atLF3e#7e6-;7Z(0Zl(SfUjAXDhb?bmaNe8rkZu z%088@A>wD@rS&*>ybd7;9A-z}JTKL*Jw&-6TOgA{StK_EcRH*rNTn7Ah6J#Fd+jS0 z-QhLQ87~EfA!V`ve@&vR(dfhrVAtyao8pz+2lvvb%V)^{FzV-u(b@|S!|%wC;KS4h z^tM_HV$~{~{6>xA7e|(~X#pj@!C=a%ocsw#925&PigC+GPe(Znou6Xr4U|D1Lv<~E zeP?1GKkP&8`~ssfC@;Xo3`3*`rr>6eyJA_iz*Ul}au{X8H1?{_1U&N{dw(}l7teux z)Io*W|(cY_FPu zP9d@U5%e<>zt;~izHh#Yu5M~r%CmRmmB1VvkD~=LM+n?%D$W_Y4!HHF+f#C_feX?p zq&+xGqOYk;dfzu@VuYXflk1(4f0jsIrSH>ney_HJjm$kk|Fc(m%t9&pY!AeVyW^ch<00 zaOHGeInZ2qio@1MEjBT1@Y6}Il2*Xo0Gu`Yvv+ZgdYD3`+9kk7{(gs3PE50&yJ@sL!=k~S1OH`-hw91z82@&aTx4N-?Oj zW3k8M<-!s6z@7rkMhFj7zZ5H6%gqhibr;EQ|(96Oi+HV+Zcxdoli_iDu`Srj?%y4;~kGWUNq z!d^S@b-9%z8jX~(rSG3-Fgle>V^QuZ`99!a3(TpE!B*b&u6?8j>AeqfTzWrg@+6`v z*c1N7rJpm*km74I;^=9LEZ>ERU#o!rapJ$lPD%JK41SX9S(@+!D-1End1Gslo~2G? zRv9>Idkas^NM%xW?2LE63w^ClHm>(RR+gyWPf_h#?CNpAE1RO+lKjWI3S-0<54vQe z>%u*yKZ^k(S=E-5mwIi6VTN@fPQY^_=fz$33&dv?Gpvo?@RnT$Gygp1DdC%y)T1E# z>U~zy!xU3F`fvOA!4K|0Jyo$d8Z$r3BOjjh3EV2X!2hw{1>a2OjyN$!55>`??i}o} zMu|@Mmo=nBQst21EK;))5X*}XdbYwLc|?e`@33m@K{#kM_l ziUL-7-1}~wm(G^bbv8z3;nb%wNllfc`{KI$taSZ+nq&g!d&81Gse7d84ay`ZlZ}$S zwtxNQ=dg~FtZ3ARekG%k#b|`c<a}!zts=?~t5;5;|EJs=qKB znQ~Y=tlR-$io1-}gY7&VNcfn=o~=p)yC}~?)0nxMyFta7o1g=Z5?;5$i_5`14q}^q zS3+AK$si5c7q|L%8Sa$itLEDv<_v(Cqdl`Rqzp=b@|H(ak=PMWFz5>C&qVsObKzdo zx;?dX>aC*@hZ$+RTx*hZZjt*Qp}UW&4l&z8JsAOvwsG1UwIc948ag&T{@JWYRI_NG zr+`-A7bS^CYWb?ICZy<2(-|~O#p}}QP>`=EvcHQD2{{z!x?LA66F0a`GbeLx(66RX z@GapDIIK2UeV)0mjD}cZ6VY+ZU=E)^P8-~79{%*jwEbnvFzzPaiNJ{ZH?ZC;YkTE{ z45AR{Co|SJdov~s8t7jy+5kXblMk^TeC`E*bQ^9o zbW4aNp(56%Lq4&SJa^;yGCOTvz6GBLy&C8wL!6!ONaz`Q<^;bu`Zma{R|OBXmg(H z?Cu;zuvg-~a4yj&NQ%sy%`P{dr`bS~pnBS^U0&OqWa0n<8*9l5{k7&#{zKi!K`Wd>xsnWCcDw4^9IdGS_C>Lm7UAZ ze-F5QIBCdj)n3QrzE)knW7_& zj#QA&OHK~CAL5tGG-2k@r8?I;ia<$!O|S;l8kFn&-qW9M;_%Q+Vo2umJl&HOY*7fv zTs6BS$dlfl>qpc@Nk8$sjj}L@o#b-;rYw?sQU)U8ANtf|T|kwK^U{WX!JV03gY>*P zE++Z9qvS3+Z5xPP;I2nkFq9GOV9{>spVb*l6U-Zi8o`D;CYn;qHY1Wu?#lh^8cPxD zzpTbmN00>L{1>9S%7-j#B$`i0fL*Qujin)_!cg|q&TGk~+XIIeCD0&4yJ@(4fVo0m%=8XYGE(-V@V5grR`dE@`5-P(?C1Knpvi& zxDXVg3vMIoH!auHm67607e6u%+K2*Fh0;6Jt$r({kUprcW47)+rL%u4UVNXX8Tf4s zzqrgk_kVA${r}G*K=ZfuU8~C+t7W!rY%$#>15hCQ@Z;&Qw`jF4nenF|Z>dSfN*W*~ zZ6!2YmwYx@XgIrxe!Hk(@qwcj9&)b!(hCXSwMvTU`~L2!OMb2XG9$AM_@fZB_TtaS z()1rc;m_A=&$XJO^2g7g5PhsFt|}_L{N3Y&S!27XGV*tinV$drAE$;wtxC8}AKGKD T7ErSG+b>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}} +\toprule +~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline +~ & Type & Reference Capacity[W] & Type Reference Efficiency [W/W] & Rated Capacity [W] & Rated Efficiency [W/W] & IPLV in SI Units [W/W] & IPLV in IP Units [Btu/W-h] & Minimum Part Load Ratio & Fuel Type & Rated Entering Condenser Temperature [C] & Rated Leaving Evaporator Temperature [C] Reference Entering Condenser Temperature [C] Reference Leaving Evaporator Temperature [C] Design Size Reference Chilled Water Flow Rate [kg/s] Design Size Reference Condenser Fluid Flow Rate [kg/s] Plantloop Name Plantloop Branch Name Condenser Loop Name Condenser Loop Branch Name Heat Recovery Plantloop Name Heat Recovery Plantloop Branch Name Recovery Relative Capacity Fraction + +\midrule +\endfirsthead + +\toprule +~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline +\midrule +\endhead + +Type Reference Capacity[W] TypeReference Efficiency [W/W] Rated Capacity [W] Rated Efficiency [W/W] IPLV in SI Units [W/W] IPLV in IP Units [Btu/W-h] Minimum Part Load Ratio Fuel Type Rated Entering Condenser Temperature [C] Rated Leaving Evaporator Temperature [C] Reference Entering Condenser Temperature [C] Reference Leaving Evaporator Temperature [C] Design Size Reference Chilled Water Flow Rate [kg/s] Design Size Reference Condenser Fluid Flow Rate [kg/s] Plantloop Name Plantloop Branch Name Condenser Loop Name Condenser Loop Branch Name Heat Recovery Plantloop Name Heat Recovery Plantloop Branch Name Recovery Relative Capacity Fraction +90.1-2004 WATERCOOLED CENTRIFUGAL CHILLER 0 416TONS 0.6KW/TON Chiller:Electric:EIR 1932343.27 6.10 1932343.27 6.10 6.88 6.92 0.00 Electricity 35.00 6.67 35.00 6.67 82.04 96.29 CHILLED WATER LOOP CHILLED WATER LOOP SUPPLY BRANCH 1 CONDENSER WATER LOOP CONDENSER WATER LOOP DEMAND BRANCH 2 N/A N/A 0.00 +90.1-2004 WATERCOOLED CENTRIFUGAL CHILLER 1 416TONS 0.6KW/TON Chiller:Electric:EIR 1932343.27 6.10 1932343.27 6.10 6.88 6.92 0.00 Electricity 35.00 6.67 35.00 6.67 82.04 96.29 CHILLED WATER LOOP CHILLED WATER LOOP SUPPLY BRANCH 2 CONDENSER WATER LOOP CONDENSER WATER LOOP DEMAND BRANCH 3 N/A N/A 0.00 + + + + + + +SPACE1-1 ZONE COIL & Coil:Heating:Fuel & 17614.83 & 0.80 \tabularnewline +SPACE2-1 ZONE COIL & Coil:Heating:Fuel & 14619.82 & 0.80 \tabularnewline +SPACE3-1 ZONE COIL & Coil:Heating:Fuel & 16093.74 & 0.80 \tabularnewline +SPACE4-1 ZONE COIL & Coil:Heating:Fuel & 18942.35 & 0.80 \tabularnewline +SPACE5-1 ZONE COIL & Coil:Heating:Fuel & 19146.73 & 0.80 \tabularnewline +MAIN HEATING COIL 1 & Coil:Heating:Fuel & 19754.61 & 0.80 \tabularnewline +\bottomrule +\end{longtable}} + +{\scriptsize +\begin{longtable}[c]{>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}} +\toprule +~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline +\midrule +\endfirsthead + +\toprule +~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline +\midrule +\endhead + +SPACE1-1 ZONE COIL & Coil:Heating:Fuel & 17614.83 & 0.80 \tabularnewline +SPACE2-1 ZONE COIL & Coil:Heating:Fuel & 14619.82 & 0.80 \tabularnewline +SPACE3-1 ZONE COIL & Coil:Heating:Fuel & 16093.74 & 0.80 \tabularnewline +SPACE4-1 ZONE COIL & Coil:Heating:Fuel & 18942.35 & 0.80 \tabularnewline +SPACE5-1 ZONE COIL & Coil:Heating:Fuel & 19146.73 & 0.80 \tabularnewline +MAIN HEATING COIL 1 & Coil:Heating:Fuel & 19754.61 & 0.80 \tabularnewline +\bottomrule +\end{longtable}} + + \subsection{Envelope Summary}\label{envelope-summary} The Envelope Summary report provides a summary of the elements of the envelope of the building. The first table describes the exterior opaque elements and the second table describes the fenestration elements. Reflectance is defined as one minus the thermal absorptance. Directly following is an example of the report. The key used to obtain this report is EnvelopeSummary. @@ -1066,6 +1358,18 @@ \subsection{Envelope Summary}\label{envelope-summary} \bottomrule \end{longtable}} +Opaque Construction Layers + +The columns for this report are shown as the ten possible layers of the construction, in order. An example of the report is shown. + +\begin{figure}[h!] +\centering +\includegraphics{media/layers-table-example.PNG} +\caption{} +\end{figure} + + + \subsection{Surface Shadowing Summary}\label{surface-shadowing-summary} @@ -1622,6 +1926,170 @@ \subsection{System Summary}\label{system-summary} \bottomrule \end{longtable} +Thermostat Schedules + +The columns for this report are shown below as a list: + +\begin{itemize} +\item + Thermostat Name 1 +\item + Control Type Schedule +\item + Control Type +\item + Control Type Name +\item + Heating Schedule +\item + Cooling Schedule +\end{itemize} + +An example of the report is shown here + +\begin{figure}[h!] +\centering +\includegraphics{media/thermostat-schedule-table-example.PNG} +\caption{} +\end{figure} + + +\subsection{HVAC Topology}\label{hvac-topology} + +The HVAC Topology report provides information about the arrangement of HVAC components in the supply and demand side of the airloop, zone equipment, and plant loop. Each row shows the additional component, sub-component, or sub-sub-component being added to the arrangement. + + +Air Loop Supply Side Component Arrangement + +The columns for this report are shown below as a list: + +\begin{itemize} +\item + Airloop Name +\item + Upstream Splitter or Mixer Name +\item + Branch Name +\item + Component Type +\item + Component Name +\item + Sub-Component Type +\item + Sub-Component Name +\item + Sub-Sub-Component Type +\item + Sub-Sub-Component Name +\item + Downstream Splitter or Mixer Name +\end{itemize} + +An example of the report is shown here + +\begin{figure}[h!] +\centering +\includegraphics{media/air-supply-side-table-example.PNG} +\caption{} +\end{figure} + + +Air Loop Demand Side Component Arrangement + +The columns for this report are shown below as a list: + +\begin{itemize} +\item + Airloop Name +\item + Supply Branch Name +\item + Supply Branch Type +\item + Supply Path Component Type +\item + Supply Path Component Name +\item + Zone Name +\item + Terminal Unit Type +\item + Terminal Unit Name +\item + Return Path Component Type +\item + Return Path Component Name +\end{itemize} + +An example of the report is shown here + +\begin{figure}[h!] +\centering +\includegraphics{media/air-demand-side-table-example.PNG} +\caption{} +\end{figure} + + +Zone Equipment Component Arrangement + +The columns for this report are shown below as a list: + +\begin{itemize} +\item + Zone Name +\item + Component Type +\item + Component Name +\item + Sub-Component Type +\item + Sub-Component Name +\item + Sub-Sub-Component Type +\item + Sub-Sub-Component Name +\end{itemize} + +An example of the report is shown here + +\begin{figure}[h!] +\centering +\includegraphics{media/zone-equipment-table-example.png} +\caption{} +\end{figure} + + +Plant Loop Component Arrangement + +The columns for this report are shown below as a list: + +\begin{itemize} +\item + Loop Type +\item + Loop Name +\item + Side +\item + Splitter/Mixer Name +\item + Branch Name +\item + Component Type +\item + Component Name +\end{itemize} + +An example of the report is shown here + +\begin{figure}[h!] +\centering +\includegraphics{media/plant-loop-table-example.png} +\caption{} +\end{figure} + \subsection{Component Sizing Summary}\label{component-sizing-summary} The Component Sizing Summary report includes details on many of the HVAC components in the simulation. For each of the components, one or more parameters are shown. Directly following is an example of the report. The key used to obtain this report is ComponentSizingSummary. From 62c6c59031ed915a5a99609f509990ad3b7fd1ad Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Mon, 1 Jul 2024 14:18:51 -0500 Subject: [PATCH 085/115] Described the output changes in OutputChanges24-1-0-to-24-2-0.md --- .../OutputChanges24-1-0-to-24-2-0.md | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md b/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md index 4c0be986bee..49fa0aef7fe 100644 --- a/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md +++ b/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md @@ -42,4 +42,31 @@ These changes will also make corresponding changes in the HTML Intialization Sum ### Adding an Output:Variable, Zone/Space Wetbulb Globe Temperature An output variable will be added at both zone and space level: Zone Wetbulb Globe Temperature, and Space Wetbulb Globe -Temperature \ No newline at end of file +Temperature + +### EnvelopeSummary in Tabular Reports + +In the Opaque Exterior table added “Zone” column + +Add an entirely new table called Opaque Construction Layers which shows the layers of materials for each construction + + +### EquipmentSummary in Tabular Reports + +In the DX Heating Coils table added "Supplemental Heat High Shutoff Temperature” + +In the Fans table added "Motor Loss Zone Name" + +Added an entirely new table called Air Terminals + +### SystemSummary in Tabular Reports + +In the Demand Controlled Ventilation table added the "type" + +Added an entirely new table called Thermostat Schedules + +## New HVAC Topology report in Tabular Reports + +The HVAC Topology report provides information about the arrangement of HVAC components in the supply and demand side of the airloop, zone equipment, and plant loop. Each row shows the additional component, sub-component, or sub-sub-component being added to the arrangement. + + From 24c86679c02b7bd931265325d24cfc45773d62fe Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Tue, 2 Jul 2024 07:33:50 -0400 Subject: [PATCH 086/115] DX Heating Coil standard ratings reporting by AHRI versions --- src/EnergyPlus/DataHVACGlobals.hh | 1 + src/EnergyPlus/StandardRatings.cc | 9 +++++---- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/EnergyPlus/DataHVACGlobals.hh b/src/EnergyPlus/DataHVACGlobals.hh index 139585abe53..2044ae368ab 100644 --- a/src/EnergyPlus/DataHVACGlobals.hh +++ b/src/EnergyPlus/DataHVACGlobals.hh @@ -526,6 +526,7 @@ struct HVACGlobalsData : BaseGlobalStruct bool StandardRatingsMyCoolOneTimeFlag = true; bool StandardRatingsMyCoolOneTimeFlag2 = true; bool StandardRatingsMyHeatOneTimeFlag = true; + bool StandardRatingsMyHeatOneTimeFlag2 = true; void init_state([[maybe_unused]] EnergyPlusData &state) override { diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index ee008bd4bc6..e85f7588acd 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -6888,16 +6888,17 @@ namespace StandardRatings { state, state.dataOutRptPredefined->pdstDXHeatCoil, "ANSI/AHRI ratings account for supply air fan heat and electric power."); } else { // ANSI/AHRI 210/240 Standard 2023 Ratings | HSPF2 - if (state.dataHVACGlobal->StandardRatingsMyHeatOneTimeFlag) { + if (state.dataHVACGlobal->StandardRatingsMyHeatOneTimeFlag2) { static constexpr std::string_view Format_992_( - "! , Component Type, Component Name, High Temperature Heating " + "! , Component Type, Component Name, High Temperature Heating " "(net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region " "Number\n"); print(state.files.eio, "{}", Format_992_); - state.dataHVACGlobal->StandardRatingsMyHeatOneTimeFlag = false; + state.dataHVACGlobal->StandardRatingsMyHeatOneTimeFlag2 = false; } - static constexpr std::string_view Format_993_(" DX Heating Coil Standard Rating Information, {}, {}, {:.1R}, {:.1R}, {:.2R}, {}\n"); + static constexpr std::string_view Format_993_( + " DX Heating Coil AHRI 2023 Standard Rating Information, {}, {}, {:.1R}, {:.1R}, {:.2R}, {}\n"); print(state.files.eio, Format_993_, CompType, CompName, HighHeatingCapVal, LowHeatingCapVal, HSPFValueIP, RegionNum); PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilType_2023, CompName, CompType); From cf65cb1509e0b6a13c45186f6a8487134420ce44 Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Tue, 2 Jul 2024 07:40:48 -0400 Subject: [PATCH 087/115] Changed Equipment Summary Header for DX Heating Coils --- src/EnergyPlus/OutputReportPredefined.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 79575aaf29e..7383affd728 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -392,7 +392,7 @@ namespace OutputReportPredefined { s->pdchDXHeatCoilAirloopName = newPreDefColumn(state, s->pdstDXHeatCoil, "Airloop Name"); // for DX Heating Coil AHRI Standard 2023 Ratings | HSPF2 - s->pdstDXHeatCoil_2023 = newPreDefSubTable(state, s->pdrEquip, "DX Heating Coils [ HSPF2 ]"); + s->pdstDXHeatCoil_2023 = newPreDefSubTable(state, s->pdrEquip, "DX Heating Coils AHRI 2023"); s->pdchDXHeatCoilType_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "DX Heating Coil Type"); s->pdchDXHeatCoilHighCap_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "High Temperature Heating (net) Rating Capacity [W]"); s->pdchDXHeatCoilLowCap_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Low Temperature Heating (net) Rating Capacity [W]"); From aa0c1f4ae55354d2b84e6481f87da3df93f942f3 Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Tue, 2 Jul 2024 08:09:02 -0400 Subject: [PATCH 088/115] Modified unit test failed due to standard ratings header change --- tst/EnergyPlus/unit/DXCoils.unit.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tst/EnergyPlus/unit/DXCoils.unit.cc b/tst/EnergyPlus/unit/DXCoils.unit.cc index 832e50d3340..95e9ee300e9 100644 --- a/tst/EnergyPlus/unit/DXCoils.unit.cc +++ b/tst/EnergyPlus/unit/DXCoils.unit.cc @@ -4656,7 +4656,8 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput) Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000 ! , Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34415.4, 20666.4, 6.56, 4 - DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34697.2, 20948.1, 5.34, 4 +! , Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number + DX Heating Coil AHRI 2023 Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34697.2, 20948.1, 5.34, 4 )EIO"; EXPECT_TRUE(compare_eio_stream(htg_coil_eio_output, true)); } From 4417e72a29fee00c6d431808694909346ac2929e Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Tue, 2 Jul 2024 08:58:08 -0400 Subject: [PATCH 089/115] Added missing columns in the equipment summary table for DX Heating Coils 2023 AHRI --- src/EnergyPlus/DXCoils.cc | 8 ++++++++ src/EnergyPlus/OutputReportPredefined.cc | 4 ++++ src/EnergyPlus/OutputReportPredefined.hh | 2 ++ 3 files changed, 14 insertions(+) diff --git a/src/EnergyPlus/DXCoils.cc b/src/EnergyPlus/DXCoils.cc index 07949d7f1a5..fa05e370491 100644 --- a/src/EnergyPlus/DXCoils.cc +++ b/src/EnergyPlus/DXCoils.cc @@ -8691,6 +8691,14 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) equipName, thisDXCoil.AirLoopNum > 0 ? state.dataAirSystemsData->PrimaryAirSystems(thisDXCoil.AirLoopNum).Name : "N/A"); + // std 229 existing table DX Heating coil 2023 AHRI new reporting variables + OutputReportPredefined::PreDefTableEntry( + state, state.dataOutRptPredefined->pdchDXHeatCoilMinOADBTforCompOp_2023, equipName, thisDXCoil.MinOATCompressor); + OutputReportPredefined::PreDefTableEntry(state, + state.dataOutRptPredefined->pdchDXHeatCoilAirloopName_2023, + equipName, + thisDXCoil.AirLoopNum > 0 ? state.dataAirSystemsData->PrimaryAirSystems(thisDXCoil.AirLoopNum).Name + : "N/A"); } break; default: break; diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 7383affd728..72faa8116af 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -398,6 +398,10 @@ namespace OutputReportPredefined { s->pdchDXHeatCoilLowCap_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Low Temperature Heating (net) Rating Capacity [W]"); s->pdchDXHeatCoilHSPF2IP_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "HSPF2 [Btu/W-h]"); s->pdchDXHeatCoilRegionNum_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Region Number"); + // Std 229 Predef outputs for DX Heating Coils AHRI 2023 + s->pdchDXHeatCoilMinOADBTforCompOp_2023 = + newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation"); + s->pdchDXHeatCoilAirloopName_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Airloop Name"); s->pdstHeatCoil = newPreDefSubTable(state, s->pdrEquip, "Heating Coils"); diff --git a/src/EnergyPlus/OutputReportPredefined.hh b/src/EnergyPlus/OutputReportPredefined.hh index 497fb039f20..98b177d196d 100644 --- a/src/EnergyPlus/OutputReportPredefined.hh +++ b/src/EnergyPlus/OutputReportPredefined.hh @@ -360,6 +360,8 @@ struct OutputReportPredefinedData : BaseGlobalStruct int pdchDXHeatCoilHSPF2SI_2023 = 0; // HSPF2 value in SI unit at AHRI std. 340/360 conditions [W/W] int pdchDXHeatCoilHSPF2IP_2023 = 0; // HSPF2 value in IP unit at AHRI std. 340/360 conditions [Btu/W-hr] int pdchDXHeatCoilRegionNum_2023 = 0; // Region number for which HSPF is calculated + int pdchDXHeatCoilMinOADBTforCompOp_2023 = 0; + int pdchDXHeatCoilAirloopName_2023 = 0; // Heating Coil subtable int pdstHeatCoil = 0; From 20a9be3f5326f6c8fc2a6b1ec8685703f74c97e2 Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Tue, 2 Jul 2024 09:25:26 -0400 Subject: [PATCH 090/115] Added Units to DX Heating Coils Equipment Summary Table Header --- src/EnergyPlus/OutputReportPredefined.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/EnergyPlus/OutputReportPredefined.cc b/src/EnergyPlus/OutputReportPredefined.cc index 72faa8116af..e76b9c875ed 100644 --- a/src/EnergyPlus/OutputReportPredefined.cc +++ b/src/EnergyPlus/OutputReportPredefined.cc @@ -388,7 +388,7 @@ namespace OutputReportPredefined { s->pdchDXHeatCoilRegionNum = newPreDefColumn(state, s->pdstDXHeatCoil, "Region Number"); // Std 229 Predef outputs for DX Heating Coils s->pdchDXHeatCoilMinOADBTforCompOp = - newPreDefColumn(state, s->pdstDXHeatCoil, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation"); + newPreDefColumn(state, s->pdstDXHeatCoil, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation [C]"); s->pdchDXHeatCoilAirloopName = newPreDefColumn(state, s->pdstDXHeatCoil, "Airloop Name"); // for DX Heating Coil AHRI Standard 2023 Ratings | HSPF2 @@ -400,7 +400,7 @@ namespace OutputReportPredefined { s->pdchDXHeatCoilRegionNum_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Region Number"); // Std 229 Predef outputs for DX Heating Coils AHRI 2023 s->pdchDXHeatCoilMinOADBTforCompOp_2023 = - newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation"); + newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation [C]"); s->pdchDXHeatCoilAirloopName_2023 = newPreDefColumn(state, s->pdstDXHeatCoil_2023, "Airloop Name"); s->pdstHeatCoil = newPreDefSubTable(state, s->pdrEquip, "Heating Coils"); From 5bb0b674c106368c410e6dfc85c95962708e5370 Mon Sep 17 00:00:00 2001 From: Bereket Nigusse Date: Thu, 4 Jul 2024 13:47:02 -0400 Subject: [PATCH 091/115] Updated the OutputChanges file --- .../OutputChanges24-1-0-to-24-2-0.md | 30 ++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md b/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md index 4c0be986bee..12eb3377b8d 100644 --- a/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md +++ b/src/Transition/OutputRulesFiles/OutputChanges24-1-0-to-24-2-0.md @@ -42,4 +42,32 @@ These changes will also make corresponding changes in the HTML Intialization Sum ### Adding an Output:Variable, Zone/Space Wetbulb Globe Temperature An output variable will be added at both zone and space level: Zone Wetbulb Globe Temperature, and Space Wetbulb Globe -Temperature \ No newline at end of file +Temperature + +### EIO DX Heating Coil Standard Rating Information + +The EIO and html tabular output files now have a seprate heading and data stream for DX Heating Coils with the AHRI 2023 and prior versions. + +! , Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number +! , Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number + + +### Euipment Summary Report + +Renamed a table name in the Equipment Summary report: + +- from "DX Heating Coils [ HSPF2 ]" +- to "DX Heating Coils AHRI 2023" + +Added two new columnuns to the named `DX Heating Coils AHRI 2023` table to make it equivalent to an exiting `DX Heating Coils` table. + +New columns header added: + +- "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation [C]" +- "AirLoop Name" + +Renamed a column header by adding units to the `DX Heating Coils` table: + +- from "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation" +- to "Minimum Outdoor Dry-Bulb Temperature for Compressor Operation [C]" + From a19b1093dccd35c5479ed7a6a697dc3223ce9c6f Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Fri, 5 Jul 2024 09:15:52 -0500 Subject: [PATCH 092/115] 10065 Var/Const Flow Restructure Created a new subroutine that avoids duplicate code and simplifies slightly the ChillerHeater subroutine. --- src/EnergyPlus/PlantCentralGSHP.cc | 93 ++++++++++++------------------ src/EnergyPlus/PlantCentralGSHP.hh | 3 + 2 files changed, 41 insertions(+), 55 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index 323da9bafe3..ab7f4562c7c 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -2442,34 +2442,8 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Mode 4 uses all data from the chilled water loop due to no heating demand if (this->SimulClgDominant || CurrentMode == 3) { CurrentMode = 3; - Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, - CondInletTemp, - state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, - RoutineName); - QCondenser = this->ChillerHeater(ChillerHeaterNum).Report.QCondSimul; - - if (this->VariableFlowCH) { // Variable flow - Real64 CondMassFlowRateCalc = QCondenser / CondDeltaTemp / Cp; - if (CondMassFlowRateCalc > CondMassFlowRate) { - CondMassFlowRateCalc = CondMassFlowRate; - Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; - if (CondDeltaTempCalc > CondDeltaTemp) { // Load to meet should be adjusted - QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; - } - } - CondMassFlowRate = CondMassFlowRateCalc; - } else { // Constant flow control - Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; - Real64 CondOutletTempCalc = CondDeltaTempCalc + CondInletTemp; - if (CondOutletTempCalc > CondOutletTemp) { - CondOutletTempCalc = CondOutletTemp; - QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; - } - CondOutletTemp = CondOutletTempCalc; - } - + this->adjustChillerHeaterFlowTemp(state, QCondenser, CondMassFlowRate, CondOutletTemp, CondInletTemp, CondDeltaTemp); } else { // Either Mode 2 or 3 or 5 if (this->SimulHtgDominant) { CurrentMode = 5; @@ -2646,37 +2620,13 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Set load this chiller heater should meet and temperatures given QCondenser = min(HeatingLoadToMeet, QCondenser); - Cp = FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, - CondInletTemp, - state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, - RoutineNameElecEIRChiller); - - // Calculate temperatures for constant flow and mass flow rate for variable flow - // Limit mass for this chiller heater to the available mass at given temperature conditions - // when mass calculated to meet the load is greater than the maximum available + // Calculate outlet temperature for constant flow and mass flow rate for variable flow + // Limit mass flow rate for this chiller heater to the available mass at given temperature conditions + // when mass flow rate calculated to meet the load is greater than the maximum available // then recalculate heating load this chiller heater can meet if (CurrentMode == 2 || this->SimulHtgDominant) { if (CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance && CondDeltaTemp > 0.0) { - if (this->VariableFlowCH) { // Variable flow - Real64 CondMassFlowRateCalc = QCondenser / CondDeltaTemp / Cp; - if (CondMassFlowRateCalc > CondMassFlowRate) { - CondMassFlowRateCalc = CondMassFlowRate; - Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; - if (CondDeltaTempCalc > CondDeltaTemp) { // Load to meet should be adjusted - QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; - } - } - CondMassFlowRate = CondMassFlowRateCalc; - } else { // Constant Flow at a fixed flow rate and capacity - Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; - Real64 CondOutletTempCalc = CondDeltaTempCalc + CondInletTemp; - if (CondOutletTempCalc > CondOutletTemp) { // Load to meet should be adjusted - CondOutletTempCalc = CondOutletTemp; - QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; - } - CondOutletTemp = CondOutletTempCalc; - } + this->adjustChillerHeaterFlowTemp(state, QCondenser, CondMassFlowRate, CondOutletTemp, CondInletTemp, CondDeltaTemp); } else { QCondenser = 0.0; CondOutletTemp = CondInletTemp; @@ -2757,6 +2707,39 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) } } +void WrapperSpecs::adjustChillerHeaterFlowTemp(EnergyPlusData &state, Real64 &QCondenser, + Real64 &CondMassFlowRate, Real64 &CondOutletTemp, + Real64 const CondInletTemp, Real64 const CondDeltaTemp) +{ + // Based on whether this is variable or constant flow, adjust either flow or outlet temperature and also the load + static constexpr std::string_view RoutineName("adjustChillerHeaterFlow"); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, + state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, + CondInletTemp, + state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, + RoutineName); + + if (this->VariableFlowCH) { // Variable Flow (adjust flow and condenser load as needed) + Real64 CondMassFlowRateCalc = QCondenser / CondDeltaTemp / Cp; + if (CondMassFlowRateCalc > CondMassFlowRate) { + CondMassFlowRateCalc = CondMassFlowRate; + Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; + if (CondDeltaTempCalc > CondDeltaTemp) { // Load to meet should be adjusted + QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; + } + } + CondMassFlowRate = CondMassFlowRateCalc; + } else { // Constant Flow (adjust outlet temperature and condenser load as needed) + Real64 CondDeltaTempCalc = QCondenser / CondMassFlowRate / Cp; + Real64 CondOutletTempCalc = CondDeltaTempCalc + CondInletTemp; + if (CondOutletTempCalc > CondOutletTemp) { // Load to meet should be adjusted + CondOutletTempCalc = CondOutletTemp; + QCondenser = CondMassFlowRate * Cp * CondDeltaTemp; + } + CondOutletTemp = CondOutletTempCalc; + } +} + void WrapperSpecs::CalcWrapperModel(EnergyPlusData &state, Real64 &MyLoad, int const LoopNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index 7121e3e1217..304ecbf6f36 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -406,6 +406,9 @@ namespace PlantCentralGSHP { void CalcChillerModel(EnergyPlusData &state); void CalcChillerHeaterModel(EnergyPlusData &state); + + void adjustChillerHeaterFlowTemp(EnergyPlusData &state, Real64 &QCondenser, Real64 &CondMassFlowRate, + Real64 &CondOutletTemp, Real64 const CondInletTemp, Real64 const CondDeltaTemp); void UpdateChillerHeaterRecords(EnergyPlusData &state); From 4ac97f53f87d0ba6a1104bf512ac3afc589f23de Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Fri, 5 Jul 2024 09:38:58 -0500 Subject: [PATCH 093/115] 10065 Var/Const Flow Restructure Clang Forgot the clang formatting for these changes. --- src/EnergyPlus/PlantCentralGSHP.cc | 11 +++++++---- src/EnergyPlus/PlantCentralGSHP.hh | 10 +++++++--- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index ab7f4562c7c..b249d7e1c0e 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -2707,9 +2707,12 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) } } -void WrapperSpecs::adjustChillerHeaterFlowTemp(EnergyPlusData &state, Real64 &QCondenser, - Real64 &CondMassFlowRate, Real64 &CondOutletTemp, - Real64 const CondInletTemp, Real64 const CondDeltaTemp) +void WrapperSpecs::adjustChillerHeaterFlowTemp(EnergyPlusData &state, + Real64 &QCondenser, + Real64 &CondMassFlowRate, + Real64 &CondOutletTemp, + Real64 const CondInletTemp, + Real64 const CondDeltaTemp) { // Based on whether this is variable or constant flow, adjust either flow or outlet temperature and also the load static constexpr std::string_view RoutineName("adjustChillerHeaterFlow"); @@ -2718,7 +2721,7 @@ void WrapperSpecs::adjustChillerHeaterFlowTemp(EnergyPlusData &state, Real64 &QC CondInletTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, RoutineName); - + if (this->VariableFlowCH) { // Variable Flow (adjust flow and condenser load as needed) Real64 CondMassFlowRateCalc = QCondenser / CondDeltaTemp / Cp; if (CondMassFlowRateCalc > CondMassFlowRate) { diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index 304ecbf6f36..018d210b823 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -406,9 +406,13 @@ namespace PlantCentralGSHP { void CalcChillerModel(EnergyPlusData &state); void CalcChillerHeaterModel(EnergyPlusData &state); - - void adjustChillerHeaterFlowTemp(EnergyPlusData &state, Real64 &QCondenser, Real64 &CondMassFlowRate, - Real64 &CondOutletTemp, Real64 const CondInletTemp, Real64 const CondDeltaTemp); + + void adjustChillerHeaterFlowTemp(EnergyPlusData &state, + Real64 &QCondenser, + Real64 &CondMassFlowRate, + Real64 &CondOutletTemp, + Real64 const CondInletTemp, + Real64 const CondDeltaTemp); void UpdateChillerHeaterRecords(EnergyPlusData &state); From 008e511baab92fcd5f488f0b74d15b3820488282 Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Mon, 8 Jul 2024 07:59:58 -0500 Subject: [PATCH 094/115] 10065 SetCondTemp Restructure Next step: more simplification of the code, this time dealing with the handling of the condenser water temperature. Decision now based on enum and handled by a Real64 function. --- src/EnergyPlus/PlantCentralGSHP.cc | 64 +++++------ src/EnergyPlus/PlantCentralGSHP.hh | 175 +++++++++++++++-------------- 2 files changed, 124 insertions(+), 115 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index b249d7e1c0e..b21addc7327 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -1206,7 +1206,11 @@ void GetChillerHeaterInput(EnergyPlusData &state) state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).Name = state.dataIPShortCut->cAlphaArgs(1); Util::IsNameEmpty(state, state.dataIPShortCut->cAlphaArgs(1), state.dataIPShortCut->cCurrentModuleObject, CHErrorsFound); - state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeCooling = state.dataIPShortCut->cAlphaArgs(4); + if (Util::SameString(state.dataIPShortCut->cAlphaArgs(4), "LEAVINGCONDENSER")) { + state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeCooling = CondenserModeTemperature::LeavingCondenser; + } else { // only other option and default value is EnteringCondenser + state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeCooling = CondenserModeTemperature::EnteringCondenser; + } // Performance curves state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).ChillerCapFTCoolingIDX = @@ -1233,7 +1237,11 @@ void GetChillerHeaterInput(EnergyPlusData &state) CHErrorsFound = true; } - state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeHeating = state.dataIPShortCut->cAlphaArgs(8); + if (Util::SameString(state.dataIPShortCut->cAlphaArgs(8), "LEAVINGCONDENSER")) { + state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeHeating = CondenserModeTemperature::LeavingCondenser; + } else { // only other option and default value is EnteringCondenser + state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).CondModeHeating = CondenserModeTemperature::EnteringCondenser; + } // Performance curves state.dataPlantCentralGSHP->ChillerHeater(ChillerHeaterNum).ChillerCapFTHeatingIDX = @@ -1975,18 +1983,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) // Only used to read curve values CondOutletTemp = this->ChillerHeater(ChillerHeaterNum).TempRefCondOutCooling; - Real64 CondTempforCurve; - if (this->ChillerHeater(ChillerHeaterNum).CondMode == "ENTERINGCONDENSER") { - CondTempforCurve = CondInletTemp; - } else if (this->ChillerHeater(ChillerHeaterNum).CondMode == "LEAVINGCONDENSER") { - CondTempforCurve = CondOutletTemp; - } else { - ShowWarningError(state, format("ChillerHeaterPerformance:Electric:EIR \"{}\":", this->ChillerHeater(ChillerHeaterNum).Name)); - ShowContinueError(state, - format("Chiller condenser temperature for curve fit are not decided, defalt value= cond_leaving ({:.3R}).", - state.dataPlantCentralGSHP->ChillerCapFT)); - CondTempforCurve = CondOutletTemp; - } + Real64 CondTempforCurve = this->setChillerHeaterCondTemp(state, ChillerHeaterNum, CondInletTemp, CondOutletTemp); // Bind local variables from the curve Real64 MinPartLoadRat; // Min allowed operating fraction of full load @@ -2466,25 +2463,11 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) this->ChillerHeater(ChillerHeaterNum).ChillerEIRFTIDX = this->ChillerHeater(ChillerHeaterNum).ChillerEIRFTHeatingIDX; this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRIDX = this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRHeatingIDX; - Real64 CondTempforCurve; // Reference condenser temperature for the performance curve reading - - if (this->ChillerHeater(ChillerHeaterNum).CondMode == "ENTERINGCONDENSER") { - CondTempforCurve = CondInletTemp; - } else if (this->ChillerHeater(ChillerHeaterNum).CondMode == "LEAVINGCONDENSER") { - CondTempforCurve = this->ChillerHeater(ChillerHeaterNum).TempRefCondOutClgHtg; //! CondOutletTemp - } else { - ShowWarningError(state, format("ChillerHeaterPerformance:Electric:EIR \"{}\":", this->ChillerHeater(ChillerHeaterNum).Name)); - ShowContinueError(state, - format("Chiller condenser temperature for curve fit are not decided, default value= cond_leaving ({:.3R}).", - state.dataPlantCentralGSHP->ChillerCapFT)); - CondTempforCurve = - state.dataLoopNodes->Node(state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).TempSetPointNodeNum).TempSetPoint; - } - - Real64 MinPartLoadRat; // Min allowed operating fraction of full load - Real64 MaxPartLoadRat; // Max allowed operating fraction of full load + // Reference condenser temperature for the performance curve reading: set to entering or leaving condenser temperature based on user + // input + Real64 CondTempforCurve = this->setChillerHeaterCondTemp( + state, ChillerHeaterNum, CondInletTemp, this->ChillerHeater(ChillerHeaterNum).TempRefCondOutClgHtg); - Curve::GetCurveMinMaxValues(state, this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRIDX, MinPartLoadRat, MaxPartLoadRat); Real64 ChillerRefCap = this->ChillerHeater(ChillerHeaterNum).RefCap; Real64 ReferenceCOP = this->ChillerHeater(ChillerHeaterNum).RefCOP; EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).TempRefEvapOutClgHtg; @@ -2522,7 +2505,10 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Available chiller capacity as a function of temperature Real64 AvailChillerCap = ChillerRefCap * state.dataPlantCentralGSHP->ChillerCapFT; - Real64 PartLoadRat; // Operating part load ratio + Real64 PartLoadRat; // Operating part load ratio + Real64 MinPartLoadRat; // Min allowed operating fraction of full load + Real64 MaxPartLoadRat; // Max allowed operating fraction of full load + Curve::GetCurveMinMaxValues(state, this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRIDX, MinPartLoadRat, MaxPartLoadRat); // Part load ratio based on reference capacity and available chiller capacity if (AvailChillerCap > 0) { @@ -2743,6 +2729,18 @@ void WrapperSpecs::adjustChillerHeaterFlowTemp(EnergyPlusData &state, } } +Real64 +WrapperSpecs::setChillerHeaterCondTemp(EnergyPlusData &state, int const numChillerHeater, Real64 const condEnteringTemp, Real64 const condLeavingTemp) +{ + Real64 setChillerHeaterCondTemp; + if (this->ChillerHeater(numChillerHeater).CondMode == CondenserModeTemperature::EnteringCondenser) { + setChillerHeaterCondTemp = condEnteringTemp; + } else { // by default, if not EnteringCondenser, then this can only be LeavingCondenser + setChillerHeaterCondTemp = condLeavingTemp; + } + return setChillerHeaterCondTemp; +} + void WrapperSpecs::CalcWrapperModel(EnergyPlusData &state, Real64 &MyLoad, int const LoopNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index 018d210b823..09edeace039 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -72,6 +72,14 @@ namespace PlantCentralGSHP { Num }; + enum class CondenserModeTemperature + { + Invalid = -1, + EnteringCondenser, + LeavingCondenser, + Num + }; + struct CGSHPNodeData { // Members @@ -168,88 +176,88 @@ namespace PlantCentralGSHP { struct ChillerHeaterSpecs { - std::string Name; // Name of the Chiller Heater object - std::string CondModeCooling; // Cooling mode temperature curve input variable - std::string CondModeHeating; // Clg/Htg mode temperature curve input variable - std::string CondMode; // Current mode temperature curve input variable - bool ConstantFlow; // True if this is a Constant Flow Chiller - bool VariableFlow; // True if this is a Variable Flow Chiller - bool CoolSetPointSetToLoop; // True if the setpoint is missing at the outlet node - bool HeatSetPointSetToLoop; // True if the setpoint is missing at the outlet node - bool CoolSetPointErrDone; // true if setpoint warning issued - bool HeatSetPointErrDone; // true if setpoint warning issued - bool PossibleSubcooling; // flag to indicate chiller is doing less cooling that requested - int ChillerHeaterNum; // Chiller heater number - CondenserType condenserType; // Type of Condenser - only water cooled is allowed - int ChillerCapFTCoolingIDX; // Cooling capacity function of temperature curve index - int ChillerEIRFTCoolingIDX; // Elec Input to Cooling Output ratio function of temperature curve index - int ChillerEIRFPLRCoolingIDX; // Elec Input to cooling output ratio function of PLR curve index - int ChillerCapFTHeatingIDX; // Clg/Htg capacity function of temperature curve index - int ChillerEIRFTHeatingIDX; // Elec Input to Clg/Htg Output ratio function of temperature curve index - int ChillerEIRFPLRHeatingIDX; // Elec Input to Clg/Htg output ratio function of PLR curve index - int ChillerCapFTIDX; // Capacity function of temperature curve index - int ChillerEIRFTIDX; // Elec Input to demand output ratio function of temperature curve index - int ChillerEIRFPLRIDX; // Elec Input to demand output ratio function of PLR curve index - int EvapInletNodeNum; // Node number on the inlet side of the plant (evaporator side) - int EvapOutletNodeNum; // Node number on the outlet side of the plant (evaporator side) - int CondInletNodeNum; // Node number on the inlet side of the condenser - int CondOutletNodeNum; // Node number on the outlet side of the condenser - int ChillerCapFTError; // Used for negative capacity as a function of temp warnings - int ChillerCapFTErrorIndex; // Used for negative capacity as a function of temp warnings - int ChillerEIRFTError; // Used for negative EIR as a function of temp warnings - int ChillerEIRFTErrorIndex; // Used for negative EIR as a function of temp warnings - int ChillerEIRFPLRError; // Used for negative EIR as a function of PLR warnings - int ChillerEIRFPLRErrorIndex; // Used for negative EIR as a function of PLR warnings - int ChillerEIRRefTempErrorIndex; // Used for reference temperature problems - int DeltaTErrCount; // Evaporator delta T equals 0 for variable flow chiller warning messages - int DeltaTErrCountIndex; // Index to evaporator delta T = 0 for variable flow chiller warning messages - int CondMassFlowIndex; // Index to condenser mass flow rate - Real64 RefCapCooling; // Reference cooling-mode evaporator capacity [W] - bool RefCapCoolingWasAutoSized; // true if reference cooling capacity was autosize on input - Real64 RefCOPCooling; // Reference cooling-mode COP - Real64 TempRefEvapOutCooling; // Reference cooling-mode evaporator leaving temperature [C] - Real64 TempRefCondInCooling; // Reference cooling-mode condenser entering temperature [C] - Real64 TempRefCondOutCooling; // Reference cooling-mode condenser leaving temperature [C] - Real64 MaxPartLoadRatCooling; // Maximum Part load ratio in cooling mode - Real64 OptPartLoadRatCooling; // Optimum Part load ratio in cooling mode - Real64 MinPartLoadRatCooling; // minimum Part load ratio in cooling mode - Real64 ClgHtgToCoolingCapRatio; // ratio of clg/htg-mode evaporator capacity to cooling-mode evap. cap - Real64 ClgHtgtoCogPowerRatio; // ratio of clg/htg-mode evaporator power to cooling-mode evap. power - Real64 RefCapClgHtg; // Reference clg/htg-mode evaporator capacity [W] - Real64 RefCOPClgHtg; // Reference clg/htg-mode COP - Real64 RefPowerClgHtg; // Reference clg/htg-mode evaporator power [W] - Real64 TempRefEvapOutClgHtg; // Reference clg/htg-mode evaporator leaving temperature [C] - Real64 TempRefCondInClgHtg; // Reference clg/htg-mode condenser entering temperature [C] - Real64 TempRefCondOutClgHtg; // Reference clg/htg-mode condenser leaving temperature [C] - Real64 TempLowLimitEvapOut; // Low temperature shut off [C] - Real64 MaxPartLoadRatClgHtg; // Maximum Part load ratio in simultaneous heating/cooling mode - Real64 OptPartLoadRatClgHtg; // Optimum Part load ratio in simultaneous heating/cooling mode - Real64 MinPartLoadRatClgHtg; // minimum Part load ratio in simultaneous heating/cooling mode - CGSHPNodeData EvapInletNode; // Chiller heater evaperator inlet node - CGSHPNodeData EvapOutletNode; // Chiller heater evaperator outlet node - CGSHPNodeData CondInletNode; // Chiller heater condenser inlet node - CGSHPNodeData CondOutletNode; // Chiller heater condenser outlet node - Real64 EvapVolFlowRate; // Reference water volumetric flow rate through the evaporator [m3/s] - bool EvapVolFlowRateWasAutoSized; // true if evaporator flow rate was autosize on input - Real64 tmpEvapVolFlowRate; // temporary ref water vol flow rate for intermediate sizing [m3/s] - Real64 CondVolFlowRate; // Reference water volumetric flow rate through the condenser [m3/s] - bool CondVolFlowRateWasAutoSized; // true if condenser flow rate was autosize on input - Real64 tmpCondVolFlowRate; // temporary ref water vol flow rate for intermediate sizing [m3/s] - Real64 CondMassFlowRateMax; // Reference water mass flow rate through condenser [kg/s] - Real64 EvapMassFlowRateMax; // Reference water mass flow rate through evaporator [kg/s] - Real64 Evapmdot; // Evaporator mass flow rate [kg/s] - Real64 Condmdot; // Condenser mass flow rate [kg/s] - Real64 DesignHotWaterVolFlowRate; // Design hot water volumetric flow rate through the condenser [m3/s] - Real64 OpenMotorEff; // Open chiller motor efficiency [fraction, 0 to 1] - Real64 SizFac; // sizing factor - Real64 RefCap; // Reference evaporator capacity [W] - Real64 RefCOP; // Reference COP - Real64 TempRefEvapOut; // Reference evaporator leaving temperature [C] - Real64 TempRefCondIn; // Reference condenser entering temperature [C] - Real64 TempRefCondOut; // Reference condenser leaving temperature [C] - Real64 OptPartLoadRat; // Optimal operating fraction of full load - Real64 ChillerEIRFPLRMin; // Minimum value of PLR from EIRFPLR curve - Real64 ChillerEIRFPLRMax; // Maximum value of PLR from EIRFPLR curve + std::string Name; // Name of the Chiller Heater object + CondenserModeTemperature CondModeCooling; // Cooling mode temperature curve input variable + CondenserModeTemperature CondModeHeating; // Clg/Htg mode temperature curve input variable + CondenserModeTemperature CondMode; // Current mode temperature curve input variable + bool ConstantFlow; // True if this is a Constant Flow Chiller + bool VariableFlow; // True if this is a Variable Flow Chiller + bool CoolSetPointSetToLoop; // True if the setpoint is missing at the outlet node + bool HeatSetPointSetToLoop; // True if the setpoint is missing at the outlet node + bool CoolSetPointErrDone; // true if setpoint warning issued + bool HeatSetPointErrDone; // true if setpoint warning issued + bool PossibleSubcooling; // flag to indicate chiller is doing less cooling that requested + int ChillerHeaterNum; // Chiller heater number + CondenserType condenserType; // Type of Condenser - only water cooled is allowed + int ChillerCapFTCoolingIDX; // Cooling capacity function of temperature curve index + int ChillerEIRFTCoolingIDX; // Elec Input to Cooling Output ratio function of temperature curve index + int ChillerEIRFPLRCoolingIDX; // Elec Input to cooling output ratio function of PLR curve index + int ChillerCapFTHeatingIDX; // Clg/Htg capacity function of temperature curve index + int ChillerEIRFTHeatingIDX; // Elec Input to Clg/Htg Output ratio function of temperature curve index + int ChillerEIRFPLRHeatingIDX; // Elec Input to Clg/Htg output ratio function of PLR curve index + int ChillerCapFTIDX; // Capacity function of temperature curve index + int ChillerEIRFTIDX; // Elec Input to demand output ratio function of temperature curve index + int ChillerEIRFPLRIDX; // Elec Input to demand output ratio function of PLR curve index + int EvapInletNodeNum; // Node number on the inlet side of the plant (evaporator side) + int EvapOutletNodeNum; // Node number on the outlet side of the plant (evaporator side) + int CondInletNodeNum; // Node number on the inlet side of the condenser + int CondOutletNodeNum; // Node number on the outlet side of the condenser + int ChillerCapFTError; // Used for negative capacity as a function of temp warnings + int ChillerCapFTErrorIndex; // Used for negative capacity as a function of temp warnings + int ChillerEIRFTError; // Used for negative EIR as a function of temp warnings + int ChillerEIRFTErrorIndex; // Used for negative EIR as a function of temp warnings + int ChillerEIRFPLRError; // Used for negative EIR as a function of PLR warnings + int ChillerEIRFPLRErrorIndex; // Used for negative EIR as a function of PLR warnings + int ChillerEIRRefTempErrorIndex; // Used for reference temperature problems + int DeltaTErrCount; // Evaporator delta T equals 0 for variable flow chiller warning messages + int DeltaTErrCountIndex; // Index to evaporator delta T = 0 for variable flow chiller warning messages + int CondMassFlowIndex; // Index to condenser mass flow rate + Real64 RefCapCooling; // Reference cooling-mode evaporator capacity [W] + bool RefCapCoolingWasAutoSized; // true if reference cooling capacity was autosize on input + Real64 RefCOPCooling; // Reference cooling-mode COP + Real64 TempRefEvapOutCooling; // Reference cooling-mode evaporator leaving temperature [C] + Real64 TempRefCondInCooling; // Reference cooling-mode condenser entering temperature [C] + Real64 TempRefCondOutCooling; // Reference cooling-mode condenser leaving temperature [C] + Real64 MaxPartLoadRatCooling; // Maximum Part load ratio in cooling mode + Real64 OptPartLoadRatCooling; // Optimum Part load ratio in cooling mode + Real64 MinPartLoadRatCooling; // minimum Part load ratio in cooling mode + Real64 ClgHtgToCoolingCapRatio; // ratio of clg/htg-mode evaporator capacity to cooling-mode evap. cap + Real64 ClgHtgtoCogPowerRatio; // ratio of clg/htg-mode evaporator power to cooling-mode evap. power + Real64 RefCapClgHtg; // Reference clg/htg-mode evaporator capacity [W] + Real64 RefCOPClgHtg; // Reference clg/htg-mode COP + Real64 RefPowerClgHtg; // Reference clg/htg-mode evaporator power [W] + Real64 TempRefEvapOutClgHtg; // Reference clg/htg-mode evaporator leaving temperature [C] + Real64 TempRefCondInClgHtg; // Reference clg/htg-mode condenser entering temperature [C] + Real64 TempRefCondOutClgHtg; // Reference clg/htg-mode condenser leaving temperature [C] + Real64 TempLowLimitEvapOut; // Low temperature shut off [C] + Real64 MaxPartLoadRatClgHtg; // Maximum Part load ratio in simultaneous heating/cooling mode + Real64 OptPartLoadRatClgHtg; // Optimum Part load ratio in simultaneous heating/cooling mode + Real64 MinPartLoadRatClgHtg; // minimum Part load ratio in simultaneous heating/cooling mode + CGSHPNodeData EvapInletNode; // Chiller heater evaperator inlet node + CGSHPNodeData EvapOutletNode; // Chiller heater evaperator outlet node + CGSHPNodeData CondInletNode; // Chiller heater condenser inlet node + CGSHPNodeData CondOutletNode; // Chiller heater condenser outlet node + Real64 EvapVolFlowRate; // Reference water volumetric flow rate through the evaporator [m3/s] + bool EvapVolFlowRateWasAutoSized; // true if evaporator flow rate was autosize on input + Real64 tmpEvapVolFlowRate; // temporary ref water vol flow rate for intermediate sizing [m3/s] + Real64 CondVolFlowRate; // Reference water volumetric flow rate through the condenser [m3/s] + bool CondVolFlowRateWasAutoSized; // true if condenser flow rate was autosize on input + Real64 tmpCondVolFlowRate; // temporary ref water vol flow rate for intermediate sizing [m3/s] + Real64 CondMassFlowRateMax; // Reference water mass flow rate through condenser [kg/s] + Real64 EvapMassFlowRateMax; // Reference water mass flow rate through evaporator [kg/s] + Real64 Evapmdot; // Evaporator mass flow rate [kg/s] + Real64 Condmdot; // Condenser mass flow rate [kg/s] + Real64 DesignHotWaterVolFlowRate; // Design hot water volumetric flow rate through the condenser [m3/s] + Real64 OpenMotorEff; // Open chiller motor efficiency [fraction, 0 to 1] + Real64 SizFac; // sizing factor + Real64 RefCap; // Reference evaporator capacity [W] + Real64 RefCOP; // Reference COP + Real64 TempRefEvapOut; // Reference evaporator leaving temperature [C] + Real64 TempRefCondIn; // Reference condenser entering temperature [C] + Real64 TempRefCondOut; // Reference condenser leaving temperature [C] + Real64 OptPartLoadRat; // Optimal operating fraction of full load + Real64 ChillerEIRFPLRMin; // Minimum value of PLR from EIRFPLR curve + Real64 ChillerEIRFPLRMax; // Maximum value of PLR from EIRFPLR curve CHReportVars Report; ChillerHeaterSpecs() @@ -414,6 +422,9 @@ namespace PlantCentralGSHP { Real64 const CondInletTemp, Real64 const CondDeltaTemp); + Real64 + setChillerHeaterCondTemp(EnergyPlusData &state, int const numChillerHeater, Real64 const condEnteringTemp, Real64 const condLeavingTemp); + void UpdateChillerHeaterRecords(EnergyPlusData &state); void UpdateChillerRecords(EnergyPlusData &state); From 08c3b09ad831957340fb94dd8eeb91d2563d523f Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Mon, 8 Jul 2024 14:17:50 -0500 Subject: [PATCH 095/115] 10065 Cap as F(T) rework More restructuring for the ChillerHeater module, this time the calculation of CapFT and error checks are made into a stand-alone Real64 function. --- src/EnergyPlus/PlantCentralGSHP.cc | 90 ++++++++++++------------------ src/EnergyPlus/PlantCentralGSHP.hh | 2 + 2 files changed, 38 insertions(+), 54 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index b21addc7327..9f628c2c09e 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -1996,33 +1996,9 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) Real64 ReferenceCOP = this->ChillerHeater(ChillerHeaterNum).RefCOP; Real64 TempLowLimitEout = this->ChillerHeater(ChillerHeaterNum).TempLowLimitEvapOut; Real64 EvapOutletTempSetPoint = this->ChillerHeater(ChillerHeaterNum).TempRefEvapOutCooling; - state.dataPlantCentralGSHP->ChillerCapFT = - Curve::CurveValue(state, this->ChillerHeater(ChillerHeaterNum).ChillerCapFTIDX, EvapOutletTempSetPoint, CondTempforCurve); - - if (state.dataPlantCentralGSHP->ChillerCapFT < 0) { - if (this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError < 1 && !state.dataGlobal->WarmupFlag) { - ++this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError; - ShowWarningError(state, format("ChillerHeaterPerformance:Electric:EIR \"{}\":", this->ChillerHeater(ChillerHeaterNum).Name)); - ShowContinueError(state, - format(" ChillerHeater Capacity as a Function of Temperature curve output is negative ({:.3R}).", - state.dataPlantCentralGSHP->ChillerCapFT)); - ShowContinueError(state, - format(" Negative value occurs using an Evaporator Outlet Temp of {:.1R} and a Condenser Inlet Temp of {:.1R}.", - EvapOutletTempSetPoint, - CondInletTemp)); - ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation."); - } else if (!state.dataGlobal->WarmupFlag) { - ++this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError; - ShowRecurringWarningErrorAtEnd( - state, - "ChillerHeaterPerformance:Electric:EIR \"" + this->ChillerHeater(ChillerHeaterNum).Name + - "\": ChillerHeater Capacity as a Function of Temperature curve output is negative warning continues...", - this->ChillerHeater(ChillerHeaterNum).ChillerCapFTErrorIndex, - state.dataPlantCentralGSHP->ChillerCapFT, - state.dataPlantCentralGSHP->ChillerCapFT); - } - state.dataPlantCentralGSHP->ChillerCapFT = 0.0; - } + + // Calculate Chiller Capacity as a function of temperature and error check + state.dataPlantCentralGSHP->ChillerCapFT = this->calcChillerCapFT(state, ChillerHeaterNum, EvapOutletTempSetPoint, CondTempforCurve); // Calculate the specific heat of chilled water Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, @@ -2473,34 +2449,9 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).TempRefEvapOutClgHtg; Real64 TempLowLimitEout = this->ChillerHeater(ChillerHeaterNum).TempLowLimitEvapOut; Real64 EvapOutletTempSetPoint = this->ChillerHeater(ChillerHeaterNum).TempRefEvapOutClgHtg; - state.dataPlantCentralGSHP->ChillerCapFT = - Curve::CurveValue(state, this->ChillerHeater(ChillerHeaterNum).ChillerCapFTIDX, EvapOutletTempSetPoint, CondTempforCurve); - if (state.dataPlantCentralGSHP->ChillerCapFT < 0) { - if (this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError < 1 && !state.dataGlobal->WarmupFlag) { - ++this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError; - ShowWarningError(state, format("ChillerHeaterPerformance:Electric:EIR \"{}\":", this->ChillerHeater(ChillerHeaterNum).Name)); - ShowContinueError(state, - format(" ChillerHeater Capacity as a Function of Temperature curve output is negative ({:.3R}).", - state.dataPlantCentralGSHP->ChillerCapFT)); - ShowContinueError( - state, - format(" Negative value occurs using an Evaporator Outlet Temp of {:.1R} and a Condenser Inlet Temp of {:.1R}.", - EvapOutletTempSetPoint, - CondInletTemp)); - ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation."); - } else if (!state.dataGlobal->WarmupFlag) { - ++this->ChillerHeater(ChillerHeaterNum).ChillerCapFTError; - ShowRecurringWarningErrorAtEnd( - state, - "ChillerHeaterPerformance:Electric:EIR \"" + this->ChillerHeater(ChillerHeaterNum).Name + - "\": ChillerHeater Capacity as a Function of Temperature curve output is negative warning continues...", - this->ChillerHeater(ChillerHeaterNum).ChillerCapFTErrorIndex, - state.dataPlantCentralGSHP->ChillerCapFT, - state.dataPlantCentralGSHP->ChillerCapFT); - } - state.dataPlantCentralGSHP->ChillerCapFT = 0.0; - } + // Calculate Chiller Capacity as a function of temperature and error check + state.dataPlantCentralGSHP->ChillerCapFT = this->calcChillerCapFT(state, ChillerHeaterNum, EvapOutletTempSetPoint, CondTempforCurve); // Available chiller capacity as a function of temperature Real64 AvailChillerCap = ChillerRefCap * state.dataPlantCentralGSHP->ChillerCapFT; @@ -2741,6 +2692,37 @@ WrapperSpecs::setChillerHeaterCondTemp(EnergyPlusData &state, int const numChill return setChillerHeaterCondTemp; } +Real64 WrapperSpecs::calcChillerCapFT(EnergyPlusData &state, int const numChillerHeater, Real64 const evapOutletTemp, Real64 const condTemp) +{ + // Calculate the chiller capacity as a function of temperature + Real64 chillCapFT = Curve::CurveValue(state, this->ChillerHeater(numChillerHeater).ChillerCapFTIDX, evapOutletTemp, condTemp); + + // Tracks errors for when the capacity is calculated as less than zero + if (chillCapFT < 0) { + if (this->ChillerHeater(numChillerHeater).ChillerCapFTError < 1 && !state.dataGlobal->WarmupFlag) { + ++this->ChillerHeater(numChillerHeater).ChillerCapFTError; + ShowWarningError(state, format("ChillerHeaterPerformance:Electric:EIR \"{}\":", this->ChillerHeater(numChillerHeater).Name)); + ShowContinueError(state, format(" ChillerHeater Capacity as a Function of Temperature curve output is negative ({:.3R}).", chillCapFT)); + ShowContinueError(state, + format(" Negative value occurs using an Evaporator Outlet Temp of {:.1R} and a Condenser Inlet Temp of {:.1R}.", + evapOutletTemp, + condTemp)); + ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation."); + } else if (!state.dataGlobal->WarmupFlag) { + ++this->ChillerHeater(numChillerHeater).ChillerCapFTError; + ShowRecurringWarningErrorAtEnd( + state, + "ChillerHeaterPerformance:Electric:EIR \"" + this->ChillerHeater(numChillerHeater).Name + + "\": ChillerHeater Capacity as a Function of Temperature curve output is negative warning continues...", + this->ChillerHeater(numChillerHeater).ChillerCapFTErrorIndex, + chillCapFT, + chillCapFT); + } + chillCapFT = 0.0; + } + return chillCapFT; +} + void WrapperSpecs::CalcWrapperModel(EnergyPlusData &state, Real64 &MyLoad, int const LoopNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index 09edeace039..eb18300c545 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -425,6 +425,8 @@ namespace PlantCentralGSHP { Real64 setChillerHeaterCondTemp(EnergyPlusData &state, int const numChillerHeater, Real64 const condEnteringTemp, Real64 const condLeavingTemp); + Real64 calcChillerCapFT(EnergyPlusData &state, int const numChillerHeater, Real64 const evapOutletTemp, Real64 const condTemp); + void UpdateChillerHeaterRecords(EnergyPlusData &state); void UpdateChillerRecords(EnergyPlusData &state); From a33d65af8a67c61f38a826a392570ccd123cbe79 Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Mon, 8 Jul 2024 18:29:20 -0500 Subject: [PATCH 096/115] 10065 Evaporator Temp Checks Created a new routine that is used by both the chiller and chillerheater in this model. This is again to improve clarity in the routines and prepare for the changes that will be needed to solve the actual defect which is that the evaporator and compressor energy never get updated when heating is the predominant mode (modes 2 and 5). --- src/EnergyPlus/PlantCentralGSHP.cc | 110 ++++++++++++++--------------- src/EnergyPlus/PlantCentralGSHP.hh | 9 +++ 2 files changed, 62 insertions(+), 57 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index 9f628c2c09e..0d2860f293d 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -1985,12 +1985,6 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) CondOutletTemp = this->ChillerHeater(ChillerHeaterNum).TempRefCondOutCooling; Real64 CondTempforCurve = this->setChillerHeaterCondTemp(state, ChillerHeaterNum, CondInletTemp, CondOutletTemp); - // Bind local variables from the curve - Real64 MinPartLoadRat; // Min allowed operating fraction of full load - Real64 MaxPartLoadRat; // Max allowed operating fraction of full load - - Curve::GetCurveMinMaxValues(state, this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRIDX, MinPartLoadRat, MaxPartLoadRat); - // Chiller reference capacity Real64 ChillerRefCap = this->ChillerHeater(ChillerHeaterNum).RefCap; Real64 ReferenceCOP = this->ChillerHeater(ChillerHeaterNum).RefCOP; @@ -2021,13 +2015,17 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) // Chiller available capacity at current operating conditions [W] Real64 AvailChillerCap = ChillerRefCap * state.dataPlantCentralGSHP->ChillerCapFT; + Real64 PartLoadRat; // Operating part load ratio + Real64 MinPartLoadRat; // Min allowed operating fraction of full load + Real64 MaxPartLoadRat; // Max allowed operating fraction of full load + + Curve::GetCurveMinMaxValues(state, this->ChillerHeater(ChillerHeaterNum).ChillerEIRFPLRIDX, MinPartLoadRat, MaxPartLoadRat); + // Set load this chiller heater should meet QEvaporator = min(CoolingLoadToMeet, (AvailChillerCap * MaxPartLoadRat)); EvapOutletTemp = EvapOutletTempSetPoint; Real64 EvapDeltaTemp = EvapInletTemp - EvapOutletTemp; - Real64 PartLoadRat; // Operating part load ratio - // Calculate temperatures for constant flow and mass flow rates for variable flow if (EvapMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { if (this->SimulHtgDominant) { // Evaporator operates at full capacity for heating @@ -2061,30 +2059,9 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) EvapOutletTemp = EvapInletTemp; } - // Check evaporator temperature low limit and adjust capacity if needed - if (EvapOutletTemp < TempLowLimitEout) { - if ((EvapInletTemp - TempLowLimitEout) > DataPlant::DeltaTempTol) { - EvapOutletTemp = TempLowLimitEout; - EvapDeltaTemp = EvapInletTemp - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } else { - QEvaporator = 0.0; - EvapOutletTemp = EvapInletTemp; - } - } - - // Check if the outlet temperature exceeds the node minimum temperature and adjust capacity if needed - if (EvapOutletTemp < this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin) { - if ((this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp - this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin) > - DataPlant::DeltaTempTol) { - EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin; - EvapDeltaTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } else { - QEvaporator = 0.0; - EvapOutletTemp = EvapInletTemp; - } - } + // Run evaporator checks and adjust outlet temp and QEvaporator if necessary + WrapperSpecs::checkEvapOutletTemp( + state, ChillerHeaterNum, EvapOutletTemp, TempLowLimitEout, EvapInletTemp, QEvaporator, EvapMassFlowRate, Cp); // Calculate part load once more since evaporator capacity might be modified if (AvailChillerCap > 0.0) { @@ -2481,31 +2458,15 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) EvapOutletTemp = EvapInletTemp - EvapDeltaTemp; } - // Check that the evaporator outlet temp honors both plant loop temp low limit and also the chiller low limit - if (EvapOutletTemp < TempLowLimitEout) { - if ((this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp - TempLowLimitEout) > DataPlant::DeltaTempTol) { - EvapOutletTemp = TempLowLimitEout; - Real64 EvapDeltaTemp = this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } else { - EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp; - Real64 EvapDeltaTemp = this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } - } - - if (EvapOutletTemp < this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin) { - if ((this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp - this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin) > - DataPlant::DeltaTempTol) { - EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin; - Real64 EvapDeltaTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } else { - EvapOutletTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin; - Real64 EvapDeltaTemp = this->ChillerHeater(ChillerHeaterNum).EvapOutletNode.TempMin - EvapOutletTemp; - QEvaporator = EvapMassFlowRate * Cp * EvapDeltaTemp; - } - } + // Run evaporator checks and adjust outlet temp and QEvaporator if necessary + WrapperSpecs::checkEvapOutletTemp(state, + ChillerHeaterNum, + EvapOutletTemp, + TempLowLimitEout, + this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp, + QEvaporator, + EvapMassFlowRate, + Cp); // Evaporator operates at full load if (AvailChillerCap > 0.0) { @@ -2723,6 +2684,41 @@ Real64 WrapperSpecs::calcChillerCapFT(EnergyPlusData &state, int const numChille return chillCapFT; } +void WrapperSpecs::checkEvapOutletTemp(EnergyPlusData &state, + int const numChillerHeater, + Real64 &evapOutletTemp, + Real64 const lowTempLimitEout, + Real64 const evapInletTemp, + Real64 &qEvaporator, + Real64 &evapMassFlowRate, + Real64 const Cp) +{ + // Check evaporator temperature low limit and adjust capacity if needed + if (evapOutletTemp < lowTempLimitEout) { + if ((evapInletTemp - lowTempLimitEout) > DataPlant::DeltaTempTol) { + evapOutletTemp = lowTempLimitEout; + Real64 evapDeltaTemp = evapInletTemp - evapOutletTemp; + qEvaporator = evapMassFlowRate * Cp * evapDeltaTemp; + } else { + qEvaporator = 0.0; + evapOutletTemp = evapInletTemp; + } + } + + // Check if the outlet temperature exceeds the node minimum temperature and adjust capacity if needed + if (evapOutletTemp < this->ChillerHeater(numChillerHeater).EvapOutletNode.TempMin) { + if ((this->ChillerHeater(numChillerHeater).EvapInletNode.Temp - this->ChillerHeater(numChillerHeater).EvapOutletNode.TempMin) > + DataPlant::DeltaTempTol) { + evapOutletTemp = this->ChillerHeater(numChillerHeater).EvapOutletNode.TempMin; + Real64 evapDeltaTemp = this->ChillerHeater(numChillerHeater).EvapOutletNode.TempMin - evapOutletTemp; + qEvaporator = evapMassFlowRate * Cp * evapDeltaTemp; + } else { + qEvaporator = 0.0; + evapOutletTemp = evapInletTemp; + } + } +} + void WrapperSpecs::CalcWrapperModel(EnergyPlusData &state, Real64 &MyLoad, int const LoopNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index eb18300c545..147b2ad3a5b 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -427,6 +427,15 @@ namespace PlantCentralGSHP { Real64 calcChillerCapFT(EnergyPlusData &state, int const numChillerHeater, Real64 const evapOutletTemp, Real64 const condTemp); + void checkEvapOutletTemp(EnergyPlusData &state, + int const numChillerHeater, + Real64 &evapOutletTemp, + Real64 const lowTempLimitEout, + Real64 evapInletTemp, + Real64 &qEvaporator, + Real64 &evapMassFlowRate, + Real64 const Cp); + void UpdateChillerHeaterRecords(EnergyPlusData &state); void UpdateChillerRecords(EnergyPlusData &state); From 101f18a13e532a5456eed202f916ee75cc29d1f0 Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Tue, 9 Jul 2024 06:26:02 -0500 Subject: [PATCH 097/115] 10065 PLR and Cycling Fraction Moved repetitive code from the chiller and heater models of the chiller-heater component. This code focuses on the calculation of part load ratio and the cycling fraction (when PLR is below the minimum). --- src/EnergyPlus/PlantCentralGSHP.cc | 92 +++++++++++++----------------- src/EnergyPlus/PlantCentralGSHP.hh | 8 +++ 2 files changed, 47 insertions(+), 53 deletions(-) diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index 0d2860f293d..22b83365e15 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -2064,33 +2064,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) state, ChillerHeaterNum, EvapOutletTemp, TempLowLimitEout, EvapInletTemp, QEvaporator, EvapMassFlowRate, Cp); // Calculate part load once more since evaporator capacity might be modified - if (AvailChillerCap > 0.0) { - PartLoadRat = max(0.0, min((QEvaporator / AvailChillerCap), MaxPartLoadRat)); - } else { - PartLoadRat = 0.0; - } - - // Chiller cycles below minimum part load ratio, FRAC = amount of time chiller is ON during this time step - if (PartLoadRat < MinPartLoadRat) FRAC = min(1.0, (PartLoadRat / MinPartLoadRat)); - - // set the module level variable used for reporting FRAC - state.dataPlantCentralGSHP->ChillerCyclingRatio = FRAC; - - // Chiller is false loading below PLR = minimum unloading ratio, find PLR used for energy calculation - if (AvailChillerCap > 0.0) { - PartLoadRat = max(PartLoadRat, MinPartLoadRat); - } else { - PartLoadRat = 0.0; - } - - // set the module level variable used for reporting PLR - state.dataPlantCentralGSHP->ChillerPartLoadRatio = PartLoadRat; - - // calculate the load due to false loading on chiller over and above water side load - state.dataPlantCentralGSHP->ChillerFalseLoadRate = (AvailChillerCap * PartLoadRat * FRAC) - QEvaporator; - if (state.dataPlantCentralGSHP->ChillerFalseLoadRate < HVAC::SmallLoad) { - state.dataPlantCentralGSHP->ChillerFalseLoadRate = 0.0; - } + WrapperSpecs::calcPLRAndCyclingRatio(state, AvailChillerCap, PartLoadRat, MinPartLoadRat, MaxPartLoadRat, QEvaporator, FRAC); // Determine chiller compressor power and transfer heat calculation state.dataPlantCentralGSHP->ChillerEIRFT = @@ -2468,32 +2442,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) EvapMassFlowRate, Cp); - // Evaporator operates at full load - if (AvailChillerCap > 0.0) { - PartLoadRat = max(0.0, min((QEvaporator / AvailChillerCap), MaxPartLoadRat)); - } else { - PartLoadRat = 0.0; - } - - // Chiller cycles below minimum part load ratio, FRAC = amount of time chiller is ON during this time step - if (PartLoadRat < MinPartLoadRat) FRAC = min(1.0, (PartLoadRat / MinPartLoadRat)); - if (FRAC <= 0.0) FRAC = 1.0; // CR 9303 COP reporting issue, it should be greater than zero in this routine - state.dataPlantCentralGSHP->ChillerCyclingRatio = FRAC; - - // Chiller is false loading below PLR = minimum unloading ratio, find PLR used for energy calculation - if (AvailChillerCap > 0.0) { - PartLoadRat = max(PartLoadRat, MinPartLoadRat); - } else { - PartLoadRat = 0.0; - } - // Evaporator part load ratio - state.dataPlantCentralGSHP->ChillerPartLoadRatio = PartLoadRat; - - // calculate the load due to false loading on chiller over and above water side load - state.dataPlantCentralGSHP->ChillerFalseLoadRate = (AvailChillerCap * PartLoadRat * FRAC) - QEvaporator; - if (state.dataPlantCentralGSHP->ChillerFalseLoadRate < HVAC::SmallLoad) { - state.dataPlantCentralGSHP->ChillerFalseLoadRate = 0.0; - } + WrapperSpecs::calcPLRAndCyclingRatio(state, AvailChillerCap, PartLoadRat, MinPartLoadRat, MaxPartLoadRat, QEvaporator, FRAC); state.dataPlantCentralGSHP->ChillerEIRFT = max(0.0, Curve::CurveValue(state, this->ChillerHeater(ChillerHeaterNum).ChillerEIRFTIDX, EvapOutletTemp, CondTempforCurve)); @@ -2719,6 +2668,43 @@ void WrapperSpecs::checkEvapOutletTemp(EnergyPlusData &state, } } +void WrapperSpecs::calcPLRAndCyclingRatio(EnergyPlusData &state, + Real64 const availChillerCap, + Real64 &actualPartLoadRatio, + Real64 const minPartLoadRatio, + Real64 const maxPartLoadRatio, + Real64 const qEvaporator, + Real64 &frac) +{ + // Calculate PLR (actualPartLoadRatio) based on evaporator load and available capacity, factoring in max PLR + if (availChillerCap > 0.0) { + actualPartLoadRatio = max(0.0, min((qEvaporator / availChillerCap), maxPartLoadRatio)); + } else { + actualPartLoadRatio = 0.0; + } + + // Chiller cycles below minimum part load ratio, frac = amount of time chiller is ON during this time step + if (actualPartLoadRatio < minPartLoadRatio) frac = min(1.0, (actualPartLoadRatio / minPartLoadRatio)); + if (frac <= 0.0) frac = 1.0; // CR 9303 COP reporting issue, it should be greater than zero in this routine + state.dataPlantCentralGSHP->ChillerCyclingRatio = frac; + + // Chiller is false loading below PLR = minimum unloading ratio, find PLR used for energy calculation + if (availChillerCap > 0.0) { + actualPartLoadRatio = max(actualPartLoadRatio, minPartLoadRatio); + } else { + actualPartLoadRatio = 0.0; + } + + // Evaporator part load ratio + state.dataPlantCentralGSHP->ChillerPartLoadRatio = actualPartLoadRatio; + + // Calculate the load due to false loading on chiller over and above water side load + state.dataPlantCentralGSHP->ChillerFalseLoadRate = (availChillerCap * actualPartLoadRatio * frac) - qEvaporator; + if (state.dataPlantCentralGSHP->ChillerFalseLoadRate < HVAC::SmallLoad) { + state.dataPlantCentralGSHP->ChillerFalseLoadRate = 0.0; + } +} + void WrapperSpecs::CalcWrapperModel(EnergyPlusData &state, Real64 &MyLoad, int const LoopNum) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/PlantCentralGSHP.hh b/src/EnergyPlus/PlantCentralGSHP.hh index 147b2ad3a5b..1744470956f 100644 --- a/src/EnergyPlus/PlantCentralGSHP.hh +++ b/src/EnergyPlus/PlantCentralGSHP.hh @@ -436,6 +436,14 @@ namespace PlantCentralGSHP { Real64 &evapMassFlowRate, Real64 const Cp); + void calcPLRAndCyclingRatio(EnergyPlusData &state, + Real64 const availChillerCap, + Real64 &actualPartLoadRatio, + Real64 const minPartLoadRatio, + Real64 const maxPartLoadRatio, + Real64 const qEvaporator, + Real64 &frac); + void UpdateChillerHeaterRecords(EnergyPlusData &state); void UpdateChillerRecords(EnergyPlusData &state); From cf2debfedf20bf01d827a3a935f107a8cef9e25c Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Thu, 11 Jul 2024 10:46:03 -0500 Subject: [PATCH 098/115] 9972 Documentation Mods Part 1 An intermediate commit of various documentation mods for #9972 --- .../green-roof-model-ecoroof.tex | 2 +- .../group-hvac-templates.tex | 2 +- .../group-advanced-surface-concepts.tex | 2 +- .../src/overview/group-plant-equipment.tex | 2 +- .../src/overview/group-refrigeration.tex | 2 +- .../overview/group-simulation-parameters.tex | 4 +-- .../group-surface-construction-elements.tex | 2 +- ...roup-thermal-zone-description-geometry.tex | 12 ++++++++ .../src/overview/group-water-heaters.tex | 10 +++---- .../src/overview/group-water-systems.tex | 2 +- .../output-table-reportperiod.tex | 2 +- .../output-table-summaryreports.tex | 28 +++++++++---------- 12 files changed, 41 insertions(+), 29 deletions(-) diff --git a/doc/engineering-reference/src/advanced-surface-concepts/green-roof-model-ecoroof.tex b/doc/engineering-reference/src/advanced-surface-concepts/green-roof-model-ecoroof.tex index 10ccf68e7c0..627d85abf35 100644 --- a/doc/engineering-reference/src/advanced-surface-concepts/green-roof-model-ecoroof.tex +++ b/doc/engineering-reference/src/advanced-surface-concepts/green-roof-model-ecoroof.tex @@ -59,7 +59,7 @@ \subsubsection{Energy budget in the foliage layer}\label{energy-budget-in-the-fo Where $\sigma$\(_{f}\) is calculated as a function of Leaf-Area-Index (LAI): \begin{equation} -\sigma_f = 0.9 - 0.7 \exp{-0.75 LAI } +\sigma_f = 0.9 - 0.7 \exp^{-0.75 LAI} \end{equation} In addition to convective and sensible heat transfer this equation accounts for both the short and longwave radiation absorbed by the vegetation, including the effects of multiple reflections. The sensible and latent heat flux terms (H\(_{f}\) and L\(_{f-}\)) are somewhat complicated and therefore discussed in some detail below. diff --git a/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex b/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex index 69b8c30ca4a..cf4b2f64c6b 100644 --- a/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex +++ b/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex @@ -326,7 +326,7 @@ \subsection{HVACTemplate:Zone:IdealLoadsAirSystem}\label{hvactemplatezoneideallo This component can be operated with infinite or finite heating and cooling capacity. For either mode -- infinite or limited capacity -- the user can also specify on/off schedules for heating and cooling and outdoor air controls. There are also optional controls for dehumidification, humidification, economizer, and heat recovery. This component may be used in combination with other HVAC equipment serving the same zone. -This component can be thought of as an ideal unit that mixes air at the zone exhaust condition with the specified amount of outdoor air and then adds or removes heat and moisture at 100\% efficiency in order to produce a supply air stream at the specified conditions. The energy required to condition the supply air is metered and reported as \hyperref[districtheating]{DistrictHeating} and \hyperref[districtcooling]{DistrictCooling}. +This component can be thought of as an ideal unit that mixes air at the zone exhaust condition with the specified amount of outdoor air and then adds or removes heat and moisture at 100\% efficiency in order to produce a supply air stream at the specified conditions. The energy required to condition the supply air is metered and reported as \hyperref[districtheating]{DistrictHeatingWater} and \hyperref[districtcooling]{DistrictCooling}. \subsubsection{Inputs}\label{inputs-1-022} diff --git a/doc/input-output-reference/src/overview/group-advanced-surface-concepts.tex b/doc/input-output-reference/src/overview/group-advanced-surface-concepts.tex index f731f7fb7df..ddadfe4a7ea 100644 --- a/doc/input-output-reference/src/overview/group-advanced-surface-concepts.tex +++ b/doc/input-output-reference/src/overview/group-advanced-surface-concepts.tex @@ -2719,7 +2719,7 @@ \subsubsection{Outputs}\label{outputs-gndSrfs} This is an average surface reflectance of multiple ground surfaces viewed by an exterior surface for each time step. If there is only one ground surface specified in a given \textit{SurfaceProperty:GroundSurfaces} object, then the average surface reflectance will be the same as the specified ground surface reflectance. This output variable is not generated when all ground surface reflectance schedule name fields are blank. -\subsection{References}\label{references-gnd-srfs} +\subsubsection{References}\label{references-gnd-srfs} Bill Marion. 2018. Ground Albedo Measurements and Modeling. Bifacial PV Workshop Lakewood, Colorado. September 11, 2018. NREL/PR-5K00-72589. https://www.nrel.gov/docs/fy20osti/72589.pdf diff --git a/doc/input-output-reference/src/overview/group-plant-equipment.tex b/doc/input-output-reference/src/overview/group-plant-equipment.tex index 6b5faf42321..6daee528e50 100644 --- a/doc/input-output-reference/src/overview/group-plant-equipment.tex +++ b/doc/input-output-reference/src/overview/group-plant-equipment.tex @@ -1701,7 +1701,7 @@ \subsubsection{Inputs}\label{inputs-4-023} \paragraph{Field: Design Heat Recovery Water Flow Rate}\label{field-design-heat-recovery-water-flow-rate-1-000} -This is the design heat recovery water flow rate if the heat recovery option is being simulated. If this value is greater than 0.0 (or Autosize), a heat recovery loop must be specified and attached to the chiller using the next two node fields. The units are in cubic meters per second.~ This field is autosizable.~ When autosizing, the flow rate is simply the product of the design condenser flow rate and the condenser heat recovery relative capacity fraction set in the field below. Note that heat recovery is only available with Condenser Type = WaterCooled. +This is the design heat recovery water flow rate if the heat recovery option is being simulated. If this value is greater than 0.0 (or Autosize), a heat recovery loop must be specified and attached to the chiller using the next two node fields. The units are in cubic meters per second.~ This field is autosizable.~ When autosizing, the flow rate is simply the product of the design condenser flow rate and the condenser heat recovery relative capacity fraction set in the field below. \paragraph{Field: Heat Recovery Inlet Node Name}\label{field-heat-recovery-inlet-node-name-1-000} diff --git a/doc/input-output-reference/src/overview/group-refrigeration.tex b/doc/input-output-reference/src/overview/group-refrigeration.tex index 9592a0ecfa8..8175fec2f57 100644 --- a/doc/input-output-reference/src/overview/group-refrigeration.tex +++ b/doc/input-output-reference/src/overview/group-refrigeration.tex @@ -1338,7 +1338,7 @@ \subsubsection{Inputs}\label{inputs-3-029} \paragraph{Field: Refrigeration System Working Fluid Type}\label{field-refrigeration-system-working-fluid-type} -The type of refrigerant used by the system.~ Valid choices are R11, R123, R134A, R12, R22, R404A, R507A, or R410A. This name will be validated against Fluid Names (ref: Fluid Properties section) in the input file. Note that the corresponding property data, available in FluidPropertiesRefData.idf, must by supplied in the input file. +The type of refrigerant used by the system.~ Some potential examples of refrigerants that might be used in these systems include R11, R123, R134A, R12, R22, R404A, R507A, or R410A. The name entered in this field will be validated against the occurrences of \hyperref[fluidpropertiesname] {FluidProperties:Name} (ref: Fluid Properties section) in the input file. Note that the corresponding property data for many commonly used refrigerants is available in FluidPropertiesRefData.idf. This data must be included in the input file in which this system is defined. \paragraph{Field: Suction Temperature Control Type}\label{field-suction-temperature-control-type} diff --git a/doc/input-output-reference/src/overview/group-simulation-parameters.tex b/doc/input-output-reference/src/overview/group-simulation-parameters.tex index f835e132a67..f26cd185a3e 100644 --- a/doc/input-output-reference/src/overview/group-simulation-parameters.tex +++ b/doc/input-output-reference/src/overview/group-simulation-parameters.tex @@ -188,7 +188,7 @@ \subsubsection{Inputs}\label{inputs-3-034} This is the same as FullExterior except that instead of assuming all transmitted beam solar falls on the floor the program calculates the amount of beam radiation falling on each surface in the zone, including floor, walls and windows, by projecting the sun's rays through the exterior windows, taking into account the effect of exterior shadowing surfaces and window shading devices. -If this option is used, you should be sure that the surfaces of the zone totally enclose a space. This can be determined by viewing the \textbf{eplusout.dxf} file with a program like AutoDesk's Volo View Express. You should also be sure that the zone is \textbf{convex}. Examples of convex and non-convex zones are shown in Figure~\ref{fig:illustration-of-convex-and-non-convex-zones}. The most common non-convex zone is an L-shaped zone. (A formal definition of convex is that any straight line passing through the zone intercepts at most two surfaces.) If the zone's surfaces do not enclose a space or if the zone is not convex you should use Solar Distribution = \textbf{FullExterior} instead of \textbf{FullInteriorAndExterior}. +If this option is used, you should be sure that the surfaces of the zone totally enclose a space. This can be determined by viewing the \textbf{eplusout.dxf} file with a program like AutoDesk's Volo View Express. You should also be sure that the zone is \textbf{convex}. Examples of convex and non-convex zones are shown in Figure~\ref{fig:illustration-of-convex-and-non-convex-zones}. The most common non-convex zone is an L-shaped zone. (A formal definition of convex is that any straight line passing through the zone intercepts at most two surfaces.) If the zone's surfaces do not enclose a space, Solar Distribution should be set to \textbf{FullExterior} instead of \textbf{FullInteriorAndExterior}. If the zone or a surface in the zone is not convex, Solar Distribution should also be set to \textbf{FullExterior} instead of \textbf{FullInteriorAndExterior} unless this file is not using PolygonClipping (see the \hyperref [field-shading-calculation-method]{Shading Calculation Method} field in \hyperref[shadowcalculation]{ShadowCalculation} for more information). If you use \textbf{FullInteriorAndExterior} the program will also calculate how much beam radiation falling on the inside of an exterior window (from other windows in the zone) is absorbed by the window, how much is reflected back into the zone, and how much is transmitted to the outside. In this calculation the effect of a shading device, if present, is accounted for. @@ -568,7 +568,7 @@ \subsubsection{Inputs}\label{inputs-10-019} \item Imported \end{enumerate} -If \textbf{PixelCounting} is selected and GPU hardware (or GPU emulation) is not available, a warning will be displayed and EnergyPlus will revert to PolygonClipping. Unlike PolygonClipping, PixelCounting has no limitations related to zone concavity when used with any ``FullInterior'' solar distribution options (i.e., it can accommodate both concave and convex zones equally). +If \textbf{PixelCounting} is selected and GPU hardware (or GPU emulation) is not available, a warning will be displayed and EnergyPlus will revert to PolygonClipping. Unlike PolygonClipping, PixelCounting has no limitations related to zone concavity when used with any ``FullInterior'' solar distribution options (i.e., it can accommodate both concave and convex zones and surfaces equally). Use of the PixelCounting method requires some overhead in passing instructions between the CPU and the GPU. For low numbers of shading surfaces (less than about 200 for most hardware), PolygonClipping requires less runtime than PixelCounting. However, PixelCounting runtime scales significantly better at higher numbers of shading surfaces. diff --git a/doc/input-output-reference/src/overview/group-surface-construction-elements.tex b/doc/input-output-reference/src/overview/group-surface-construction-elements.tex index 8cd3b0f175f..a32a8141b4f 100644 --- a/doc/input-output-reference/src/overview/group-surface-construction-elements.tex +++ b/doc/input-output-reference/src/overview/group-surface-construction-elements.tex @@ -438,7 +438,7 @@ \subsubsection{Inputs}\label{inputs-5-030} \paragraph{Field: Temperature Coefficient for Thermal Conductivity}\label{field-temperature-coefficient-for-thermal-conductivity} -This field is used to enter the temperature dependent coefficient for thermal conductivity of the material.~ Units for this parameter are (W/(m-K\(^{2}\)). This is the thermal conductivity change per unit temperature excursion from 20 C. The conductivity value at 20 C is the one specified with the basic material properties of the regular material specified in the name field. The thermal conductivity is obtained from: +This field is used to enter the temperature dependent coefficient for thermal conductivity of the material.~ Units for this parameter are (W/(m-K\(^{2}\)). This is the thermal conductivity change per unit temperature excursion from 20$^\circ$C. The conductivity value at 20$^\circ$C is the one specified with the basic material properties of the regular material specified in the name field. The thermal conductivity is obtained from: \begin{equation} k = {k_o} + {k_1}({T_i} - 20) diff --git a/doc/input-output-reference/src/overview/group-thermal-zone-description-geometry.tex b/doc/input-output-reference/src/overview/group-thermal-zone-description-geometry.tex index 2c7f95fb65b..586043ef97b 100644 --- a/doc/input-output-reference/src/overview/group-thermal-zone-description-geometry.tex +++ b/doc/input-output-reference/src/overview/group-thermal-zone-description-geometry.tex @@ -295,6 +295,10 @@ \subsubsection{Zone Thermal Outputs Overview}\label{zone-thermal-outputs} Zone,Sum,Zone Total Internal Total Heating Energy {[}J{]} \item Zone,Average,Zone Total Internal Total Heating Rate {[}W{]} + \item + Zone Phase Change Material Melting Enthalpy{[{J/kg}]} + \item + Zone Phase Change Material Freezing Enthalpy{[{J/kg}]} \item HVAC,Average,Zone Exfiltration Heat Transfer Rate {[}W{]} \item @@ -660,6 +664,14 @@ \subsubsection{Space and Zone Thermal Outputs Details} These output variables represent the sum of all heat gains throughout the space or zone in Watts (for rate) or joules. This includes all heat gains from Energyplus objects that are listed in Table \ref{table:space-or-zone-total-internal-heat-gain-constituents}. +\paragraph{Zone Phase Change Material Melting Enthalpy {[}J/kg{]}}\label{zone-phase-change-material-melting-enthalpy-jkg} + +This output variable tracks the summation of all energy within a zone that is associated with phase change materials melting during the current time period in J/kg. This report is only produced when the user enters phase change materials (see \hyperref[materialpropertyphasechange]{MaterialProperty:PhaseChange}), opts to use the Conduction Finite Difference (aka CondFD) solution algorithm (see \hyperref[heatbalancealgorithm]{HeatBalanceAlgorithm}), and requests DisplayAdvancedReportVariables (see \hyperref[outputdiagnostics]{Output:Diagnostics}). + +\paragraph{Zone Phase Change Material Freezing Enthalpy {[}J/kg{]}}\label{zone-phase-change-material-freezing-enthalpy-jkg} + +This output variable tracks the summation of all energy within a zone that is associated with phase change materials freezing during the current time period in J/kg. This report is only produced when the user enters phase change materials (\hyperref[materialpropertyphasechange]{MaterialProperty:PhaseChange}), opts to use the Conduction Finite Difference (aka CondFD) solution algorithm (see \hyperref[heatbalancealgorithm]{HeatBalanceAlgorithm}), and requests DisplayAdvancedReportVariables (see \hyperref[outputdiagnostics]{Output:Diagnostics}). + \paragraph{Zone Exfiltration Heat Transfer Rate {[}W{]}}\label{zone-exfiltration-heat-transfer-rate-w} \paragraph{Zone Exfiltration Sensible Heat Transfer Rate {[}W{]}}\label{zone-exfiltration-sensible-heat-transfer-rate-w} diff --git a/doc/input-output-reference/src/overview/group-water-heaters.tex b/doc/input-output-reference/src/overview/group-water-heaters.tex index d86a0e64016..17d940f0c24 100644 --- a/doc/input-output-reference/src/overview/group-water-heaters.tex +++ b/doc/input-output-reference/src/overview/group-water-heaters.tex @@ -138,7 +138,7 @@ \subsubsection{Inputs}\label{inputs-052} \paragraph{Field: Off-Cycle Parasitic Fuel Type}\label{field-off-cycle-parasitic-fuel-type} -The type of fuel used by the off-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeating}. The fuel type can be the same or different from the Heater Fuel Type. +The type of fuel used by the off-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeatingWater}. The fuel type can be the same or different from the Heater Fuel Type. \paragraph{Field: Off-Cycle Parasitic Heat Fraction to Tank}\label{field-off-cycle-parasitic-heat-fraction-to-tank} @@ -150,7 +150,7 @@ \subsubsection{Inputs}\label{inputs-052} \paragraph{Field: On-Cycle Parasitic Fuel Type}\label{field-on-cycle-parasitic-fuel-type} -The type of fuel used by the on-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeating}. The fuel type can be the same or different from the Heater Fuel Type. +The type of fuel used by the on-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeatingWater}. The fuel type can be the same or different from the Heater Fuel Type. \paragraph{Field: On-Cycle Parasitic Heat Fraction to Tank}\label{field-on-cycle-parasitic-heat-fraction-to-tank} @@ -745,7 +745,7 @@ \subsubsection{Inputs}\label{inputs-1-049} \paragraph{Field: Heater Fuel Type}\label{field-heater-fuel-type-1} -The type of fuel used for both Heaters 1 and 2. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeating}. +The type of fuel used for both Heaters 1 and 2. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeatingWater}. \paragraph{Field: Heater Thermal Efficiency}\label{field-heater-thermal-efficiency-1} @@ -757,7 +757,7 @@ \subsubsection{Inputs}\label{inputs-1-049} \paragraph{Field: Off-Cycle Parasitic Fuel Type}\label{field-off-cycle-parasitic-fuel-type-1} -The type of fuel used by the off-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam, or \hyperref[districtheating]{DistrictHeating}. The fuel type can be the same or different from the Heater Fuel Type. +The type of fuel used by the off-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam, or \hyperref[districtheating]{DistrictHeatingWater}. The fuel type can be the same or different from the Heater Fuel Type. \paragraph{Field: Off-Cycle Parasitic Heat Fraction to Tank}\label{field-off-cycle-parasitic-heat-fraction-to-tank-1} @@ -773,7 +773,7 @@ \subsubsection{Inputs}\label{inputs-1-049} \paragraph{Field: On-Cycle Parasitic Fuel Type}\label{field-on-cycle-parasitic-fuel-type-1} -The type of fuel used by the on-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeating}. The fuel type can be the same or different from the Heater Fuel Type. +The type of fuel used by the on-cycle parasitics. The fuel type can be Electricity, NaturalGas, Propane, FuelOilNo1, FuelOilNo2, Coal, Diesel, Gasoline, OtherFuel1, OtherFuel2, DistrictHeatingSteam or \hyperref[districtheating]{DistrictHeatingWater}. The fuel type can be the same or different from the Heater Fuel Type. \paragraph{Field: On-Cycle Parasitic Heat Fraction to Tank}\label{field-on-cycle-parasitic-heat-fraction-to-tank-1} diff --git a/doc/input-output-reference/src/overview/group-water-systems.tex b/doc/input-output-reference/src/overview/group-water-systems.tex index 7455dbaa074..c8ef7a8a407 100644 --- a/doc/input-output-reference/src/overview/group-water-systems.tex +++ b/doc/input-output-reference/src/overview/group-water-systems.tex @@ -69,7 +69,7 @@ \subsubsection{Inputs}\label{inputs-053} \paragraph{Field: Peak Flow Rate}\label{field-peak-flow-rate-000} -The peak demanded hot water flow rate {[}m\(^{3}\)/s{]}. This value is multiplied by the Flow Rate Fraction Schedule (below) to determine the actual volumetric flow rate. +The peak demanded total water flow rate {[}m\(^{3}\)/s{]}. This value is multiplied by the Flow Rate Fraction Schedule (below) to determine the actual volumetric flow rate. \paragraph{Field: Flow Rate Fraction Schedule Name}\label{field-flow-rate-fraction-schedule-name-000} diff --git a/doc/input-output-reference/src/standard-output-reports/output-table-reportperiod.tex b/doc/input-output-reference/src/standard-output-reports/output-table-reportperiod.tex index 895d536e8f8..ea654657d7b 100644 --- a/doc/input-output-reference/src/standard-output-reports/output-table-reportperiod.tex +++ b/doc/input-output-reference/src/standard-output-reports/output-table-reportperiod.tex @@ -3,7 +3,7 @@ \section{Output:Table:ReportPeriod}\label{outputtablereportperiod} The Output:Table:ReportPeriod object allows the user to create a series of tabular reports over a certain subset of a simulation run period. Multiple such reporting periods may be defined, each with a unique ``Name''. Currently, it only -supports resilience reporting tables. +supports resilience reporting tables (see \hyperref[resilience-summaries]{Resilience Summaries}). When it is defined, a series of reporting-period-specific resilience summary reports will be generated at the end of all tabular reports. The results will be diff --git a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex index f352febfdaa..664a293c151 100644 --- a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex +++ b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex @@ -460,22 +460,24 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar The Heat Emissions Report provides a summary of the building heat emission to the ambient air. This report shows the heat emissions from buildings by surface heat transfer, zone exhaust, zone relief, HVAC relief, HVAC heat rejection, as well as the total emissions. The key used to obtain this report is HeatEmissionsSummary. -\paragraph{Thermal Resilience Summary}\label{ThermalResilienceSummary} +\paragraph{Resilience Summaries}\label{resilience-summaries} -The Thermal Resilience Summary provides the indoor thermal resilience metrics -unmet hours and occupant$·$hours summary report. This includes the Heat Index -Hours, OccupantHours, and OccupiedHours, Humidex Hours, OccupantHours, -OccupiedHours, Heating SET Degree-Hours, Cooling SET Degree-Hours reports, Hours -of Safety for Cold Events, Hours of Safety for Heat Events, Unmet Degree-hours, +Three difference resilience summaries are available: Thermal, CO2, and Visual. These are all described in more detail below. It is important to note two things regarding these summaries. First, they must be "scheduled" using the \hyperref[outputtablereportperiod]{Output:Table:ReportPeriod} input. Second, some of the output variables (like say Heat Index in the Thermal Resilience Summary below) have three different values: Hours, OccupantHours, and OccupiedHours. Hours refers to the number of hours when the heat index is at a certain level as reported in the table. OccupantHours is the product of the number of occupants and the zone time step. OccupiedHours refers tot the number of hours when the heat index is at a certain level AND the number of occupients is greater than zero. Thus, OccupiedHours is a time measure like Hours and OccupiedHours will always be less than or equal to Hours. + +Here is more information regarding each of the three resilience reports: + +\begin{itemize} +\item \textbf{Thermal Resilience Summary}: The Thermal Resilience Summary provides the indoor thermal resilience metrics +unmet hours and occupant$·$hours summary report. This includes: Heat Index +Hours, OccupantHours, and OccupiedHours; Humidex Hours, OccupantHours, +OccupiedHours, Heating SET Degree-Hours; Cooling SET Degree-Hours reports; Hours +of Safety for Cold Events; Hours of Safety for Heat Events; Unmet Degree-hours; and Discomfort-Weighted Exceedance OccupantHours and OccupiedHours. The Heating SET Degree-Hours and Cooling SET Degree-Hours are reported only when the Pierce model are chosen for thermal comfort calculations. To activate the Pierce SET calculation in EnergyPlus, users need to define the \textbf{People} and chose \textbf{Pierce} as the thermal comfort method. - -\paragraph{CO2 Resilience Summary}\label{CO2ResilienceSummary} - -The CO2 Resilience Summary provides the indoor CO2 level unmet hours, +\item \textbf{CO2 Resilience Summary}: The CO2 Resilience Summary provides the indoor CO2 level unmet hours, occupant$·$hours summary report for resilience. This includes the CO2 Level Hours, OccupantHours and OccupiedHours reports. To activate the $CO_2$ concentration calculation in EnergyPlus, the \textbf{ZoneAirContaminantBalance} @@ -484,16 +486,14 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar concentration in the field \textbf{Outdoor Carbon Dioxide Schedule Name}. $CO_2$ generation rate at the zone level can be specified using the \textbf{ZoneContaminantSourceAndSink:CarbonDioxide} object. - -\paragraph{Visual Resilience Summary}\label{VisualResilienceSummary} - -The Visual Resilience Summary provides the indoor illuminance level unmet hours +\item \textbf{Visual Resilience Summary}: The Visual Resilience Summary provides the indoor illuminance level unmet hours and occupant$·$hours summary report for resilience. This includes the Illuminance Level Hours, OccupantHours, and OccupiedHours reports. To activate the indoor illuminance calculation in EnergyPlus, users need to define the \textbf{Daylighting:Controls} and the \textbf{Daylighting:ReferencePoint} objects, even if no daylighting controls are actually implemented in the building simulation model. +\end{itemize} \subsubsection{Predefined Monthly Summary Reports}\label{predefined-monthly-summary-reports} From cd1ab3ea054d7a9f3d7586a6e4bd8ec9b2d136a9 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 11 Jul 2024 13:11:44 -0500 Subject: [PATCH 099/115] Addressing comments from Edwin --- src/EnergyPlus/Construction.cc | 3 +-- src/EnergyPlus/DataAirLoop.hh | 6 +++--- src/EnergyPlus/Furnaces.cc | 2 -- 3 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/EnergyPlus/Construction.cc b/src/EnergyPlus/Construction.cc index 7ccdb12ed89..553defc9163 100644 --- a/src/EnergyPlus/Construction.cc +++ b/src/EnergyPlus/Construction.cc @@ -1924,11 +1924,10 @@ void ConstructionProps::reportLayers(EnergyPlusData &state) { // Report the layers for each opaque construction in predefined tabular report // J. Glazer March 2024 - auto &opd = state.dataOutRptPredefined; if (state.dataOutRptPredefined->pdchOpqConsLayCol.size() > 0) { for (int i = 1; i <= this->TotLayers; ++i) { int layerIndex = this->LayerPoint(i); - auto const *thisMaterial = state.dataMaterial->Material(layerIndex); + auto &thisMaterial = state.dataMaterial->Material(layerIndex); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, thisMaterial->Name); } } diff --git a/src/EnergyPlus/DataAirLoop.hh b/src/EnergyPlus/DataAirLoop.hh index 18b95dec86b..e1a6e359749 100644 --- a/src/EnergyPlus/DataAirLoop.hh +++ b/src/EnergyPlus/DataAirLoop.hh @@ -85,9 +85,9 @@ namespace DataAirLoop { Array1D_int TermUnitCoolSizingIndex; // Air terminal sizing numbers for zones cooled by this air loop Array1D_int TermUnitHeatSizingIndex; // Air terminal sizing numbers for zones heated by this air loop Array1D SupplyDuctType; // 1=main, 2=cooling, 3=heating, 4=other - Array1D_int SupplyDuctBranchNum; // Supply duct branch number - Array1D_int SupplyAirPathNum; // Supply air path indexes - Array1D_int ReturnAirPathNum; // Return air path indexes + EPVector SupplyDuctBranchNum; // Supply duct branch number + EPVector SupplyAirPathNum; // Supply air path indexes + EPVector ReturnAirPathNum; // Return air path indexes }; struct AirLoopOutsideAirConnectData diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index eaabb19a4b7..1f456af1569 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -689,8 +689,6 @@ namespace Furnaces { std::string_view constexpr getAirLoopHVACHeatCoolInput("GetAirLoopHVACHeatCoolInput"); std::string_view constexpr routineName = "GetFurnaceInput"; - using namespace OutputReportPredefined; - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int FurnaceNum; // The Furnace that you are currently loading input into int GetObjectNum; // The index to each specific object name From 829453960ba30254a2708fc24843688fee1cba16 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Thu, 11 Jul 2024 13:30:19 -0500 Subject: [PATCH 100/115] Fix documentation to address Weili's comment --- .../standard-output-reports/output-table-summaryreports.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex index 5eaf80ce1df..f6927a98703 100644 --- a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex +++ b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex @@ -73,9 +73,9 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar \begin{itemize} \item - Opaque exterior which includes all exterior opaque surfaces and includes the name of the construction, zone, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. + Opaque Exterior which includes all exterior opaque surfaces and includes the name of the construction, zone, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. \item - Opaque exterior which includes all exterior opaque surfaces and includes the name of the construction, zone, adjacent surface, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. + Opaque Interior which includes all interior opaque surfaces and includes the name of the construction, zone, adjacent surface, reflectance, U-Factors, areas, azimuth, tilt, cardinal direction. \item Exterior Fenestration which includes all non-opaque exterior surfaces and includes the name of the construction, frame and divider name, areas (glass, frame, divider, single opening, multiplied openings), glass U-Factor, glass SHGC (the solar heat gain coefficient based on summer conditions), glass visible transmittance, NFRC Product Type, assembly U-Factor, assembly SHGC, assembly visible transmittance, conductance (frame, divider), indication of shade control, the name of the parent surface, azimuth, tilt, cardinal direction. \item From 59120833ce10e1fffdc897b74a2c61ac8184f9e3 Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Fri, 12 Jul 2024 07:33:11 -0500 Subject: [PATCH 101/115] 9972 Documentation Mods Part 2 Second commit containing the remaining documentation mods to address all of the issues collected under defect #9972 --- .../group-hvac-templates.tex | 16 +++++----- .../src/overview/group-design-objects.tex | 26 ++++++++++------ .../src/overview/group-heat-recovery.tex | 30 ++++++++++--------- .../group-humidifiers-and-dehumidifiers.tex | 24 +++++++++------ .../src/overview/group-hybrid-model.tex | 5 ++-- .../src/overview/group-performance-curves.tex | 16 ++++++++++ .../src/overview/group-refrigeration.tex | 6 ++-- .../src/overview/group-setpoint-managers.tex | 2 +- .../src/overview/group-water-systems.tex | 2 +- .../src/parametric-objects.tex | 6 ++-- .../output-table-summaryreports.tex | 2 +- testfiles/HybridZoneModel.idf | 4 ++- 12 files changed, 87 insertions(+), 52 deletions(-) diff --git a/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex b/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex index cf4b2f64c6b..2f0a34c14f7 100644 --- a/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex +++ b/doc/input-output-reference/src/hvac-template-objects/group-hvac-templates.tex @@ -910,7 +910,7 @@ \subsubsection{Inputs}\label{inputs-4-016} \paragraph{Field: Cooling Coil Type}\label{field-cooling-coil-type-1} -Enter the type of cooling coil. There is currently only one choices for this field, SingleSpeedDX. +Enter the type of cooling coil. There is currently only one choice for this field, SingleSpeedDX. \paragraph{Field: Cooling Coil Availability Schedule Name}\label{field-cooling-coil-availability-schedule-name-1} @@ -1156,7 +1156,7 @@ \subsubsection{Inputs}\label{inputs-5-014} \paragraph{Field: Cooling Coil Type}\label{field-cooling-coil-type-2} -Enter the type of cooling coil. There is currently only one choices for this field, SingleSspeedDX. +Enter the type of cooling coil. There is currently only one choice for this field, SingleSpeedDX. \paragraph{Field: Cooling Coil Availability Schedule Name}\label{field-cooling-coil-availability-schedule-name-2} @@ -1176,7 +1176,7 @@ \subsubsection{Inputs}\label{inputs-5-014} \paragraph{Field: Heat Pump Heating Coil Type}\label{field-heat-pump-heating-coil-type} -Enter the type of heat pump heating coil. There is currently only one choices for this field, SingleSpeedDXHeatPump. +Enter the type of heat pump heating coil. There is currently only one choice for this field, SingleSpeedDXHeatPump. \paragraph{Field: Heat Pump Heating Coil Availability Schedule Name}\label{field-heat-pump-heating-coil-availability-schedule-name} @@ -1445,7 +1445,8 @@ \subsubsection{Inputs}\label{inputs-6-011} \paragraph{Field: Cooling Coil Type}\label{field-cooling-coil-type-3} -Enter the type of cooling coil. There is currently only one choices for this field, \hyperref[coilcoolingwatertoairheatpumpequationfit]{Coil:Cooling:WaterToAirHeatPump:EquationFit}. +Enter the type of cooling coil. At the present time, there is currently only one choice for this field: + \hyperref[coilcoolingwatertoairheatpumpequationfit]{Coil:Cooling:WaterToAirHeatPump:EquationFit} \paragraph{Field: Cooling Coil Gross Rated Total Capacity}\label{field-cooling-coil-gross-rated-total-capacity-2} @@ -1461,7 +1462,8 @@ \subsubsection{Inputs}\label{inputs-6-011} \paragraph{Field: Heat Pump Heating Coil Type}\label{field-heat-pump-heating-coil-type-1} -Enter the type of heat pump heating coil. There is currently only one choices for this field, \hyperref[coilheatingwatertoairheatpumpequationfit]{Coil:Heating:WaterToAirHeatPump:EquationFit}. +Enter the type of heat pump heating coil. There is currently only one choice for this field: + \hyperref[coilheatingwatertoairheatpumpequationfit]{Coil:Heating:WaterToAirHeatPump:EquationFit}. \paragraph{Field: Heat Pump Heating Coil Gross Rated Capacity}\label{field-heat-pump-heating-coil-gross-rated-capacity-1} @@ -3654,9 +3656,7 @@ \subsubsection{Inputs}\label{inputs-16-004} \paragraph{Field: Cooling Coil Type}\label{field-cooling-coil-type-6} -Enter the type of cooling coil. There is currently only one choices for this field, - -SingleSpeedDX. Future versions may have additional cooling coil types. +Enter the type of cooling coil. There is currently only one choice for this field, SingleSpeedDX. Future versions may have additional cooling coil types. \paragraph{Field: Cooling Coil Availability Schedule Name}\label{field-cooling-coil-availability-schedule-name-5} diff --git a/doc/input-output-reference/src/overview/group-design-objects.tex b/doc/input-output-reference/src/overview/group-design-objects.tex index 0f96917a7b1..bb409c98116 100644 --- a/doc/input-output-reference/src/overview/group-design-objects.tex +++ b/doc/input-output-reference/src/overview/group-design-objects.tex @@ -752,7 +752,7 @@ \subsubsection{Component Sizing Output}\label{component-sizing-output} The complete list of objects that have autosized fields is shown in the following table. Note that spaces may be inserted in object names to facilitate readability. % table 23 -\begin{longtable}[c]{p{3.02in}p{2.97in}} +\begin{longtable}[c]{p{3.3in}p{3.3in}} \caption{Complete list of Objects with autosized Fields \label{table:complete-list-of-objects-with-autosized}} \tabularnewline \toprule Object Name & Object Name \tabularnewline @@ -767,17 +767,22 @@ \subsubsection{Component Sizing Output}\label{component-sizing-output} AirConditioner:VariableRefrigerantFlow & AirLoopHVAC \tabularnewline AirLoopHVAC:Unitary:Furnace:HeatCool & AirLoopHVAC:Unitary:Furnace:HeatOnly \tabularnewline -AirLoopHVAC:UnitaryHeatCool & AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass \tabularnewline +AirLoopHVAC:UnitaryHeatCool & \tabularnewline +AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass & \tabularnewline AirLoopHVAC:UnitaryHeatOnly & AirLoopHVAC:UnitaryHeatPump:AirToAir \tabularnewline -AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed & AirLoopHVAC:UnitaryHeatPump:WaterToAir \tabularnewline +AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed & \tabularnewline +AirLoopHVAC:UnitaryHeatPump:WaterToAir & \tabularnewline AirLoopHVAC:UnitarySystem & AirTerminal:DualDuct:ConstantVolume \tabularnewline AirTerminal:DualDuct:VAV & AirTerminal:DualDuct:VAV:OutdoorAir \tabularnewline -AirTerminal:SingleDuct:ConstantVolume:CooledBeam & AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction \tabularnewline +AirTerminal:SingleDuct:ConstantVolume:CooledBeam & \tabularnewline +AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction & \tabularnewline AirTerminal:SingleDuct:ConstantVolume:Reheat & AirTerminal:SingleDuct:ParallelPIU:Reheat \tabularnewline AirTerminal:SingleDuct:SeriesPIU:Reheat & AirTerminal:SingleDuct:ConstantVolume:NoReheat \tabularnewline -AirTerminal:SingleDuct:VAV:HeatAndCool:NoReheat & AirTerminal:SingleDuct:VAV:HeatAndCool:Reheat \tabularnewline +AirTerminal:SingleDuct:VAV:HeatAndCool:NoReheat & \tabularnewline + & AirTerminal:SingleDuct:VAV:HeatAndCool:Reheat \tabularnewline AirTerminal:SingleDuct:VAV:NoReheat & AirTerminal:SingleDuct:VAV:Reheat \tabularnewline -AirTerminal:SingleDuct:VAV:Reheat:VariableSpeedFan & Boiler:HotWater \tabularnewline +AirTerminal:SingleDuct:VAV:Reheat:VariableSpeedFan & \tabularnewline + & Boiler:HotWater \tabularnewline Boiler:Steam & Branch \tabularnewline Chiller:Absorption & Chiller:Absorption:Indirect \tabularnewline Chiller:CombustionTurbine & Chiller:ConstantCOP \tabularnewline @@ -789,13 +794,15 @@ \subsubsection{Component Sizing Output}\label{component-sizing-output} Coil:Cooling:DX:TwoSpeed & Coil:Cooling:DX:VariableRefrigerantFlow \tabularnewline Coil:Cooling:DX:VariableSpeed & Coil:Cooling:Water \tabularnewline Coil:Cooling:Water:DetailedGeometry & Coil:Cooling:WaterToAirHeatPump:EquationFit \tabularnewline -Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit & Coil:Heating:DX:MultiSpeed \tabularnewline +Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit & \tabularnewline + & Coil:Heating:DX:MultiSpeed \tabularnewline Coil:Heating:DX:SingleSpeed & Coil:Heating:DX:VariableRefrigerantFlow \tabularnewline Coil:Heating:DX:VariableSpeed & Coil:Heating:Electric \tabularnewline Coil:Heating:Electric:MultiStage & Coil:Heating:Fuel \tabularnewline Coil:Heating:Gas:MultiStage & Coil:Heating:Steam \tabularnewline Coil:Heating:Water & Coil:Heating:WaterToAirHeatPump:EquationFit \tabularnewline -Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit & CoilPerformance:DX:Cooling \tabularnewline +Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit & \tabularnewline + & CoilPerformance:DX:Cooling \tabularnewline CondenserLoop & Controller:OutdoorAir \tabularnewline Controller:WaterCoil & CoolingTower:SingleSpeed \tabularnewline CoolingTower:TwoSpeed & CoolingTower:VariableSpeed \tabularnewline @@ -811,7 +818,8 @@ \subsubsection{Component Sizing Output}\label{component-sizing-output} HVACTemplate:Plant:Tower & HVACTemplate:System:ConstantVolume \tabularnewline HVACTemplate:System:DedicatedOutdoorAir & HVACTemplate:System:DualDuct \tabularnewline HVACTemplate:System:PackagedVAV & HVACTemplate:System:Unitary \tabularnewline -HVACTemplate:System:UnitaryHeatPump:AirToAir & HVACTemplate:System:UnitarySystem \tabularnewline +HVACTemplate:System:UnitaryHeatPump:AirToAir & \tabularnewline + & HVACTemplate:System:UnitarySystem \tabularnewline HVACTemplate:System:VAV & HVACTemplate:System:VRF \tabularnewline HVACTemplate:Zone:BaseboardHeat & HVACTemplate:Zone:ConstantVolume \tabularnewline HVACTemplate:Zone:DualDuct & HVACTemplate:Zone:FanCoil \tabularnewline diff --git a/doc/input-output-reference/src/overview/group-heat-recovery.tex b/doc/input-output-reference/src/overview/group-heat-recovery.tex index e260ced39fa..389ee84b337 100644 --- a/doc/input-output-reference/src/overview/group-heat-recovery.tex +++ b/doc/input-output-reference/src/overview/group-heat-recovery.tex @@ -264,12 +264,6 @@ \subsubsection{Inputs}\label{inputs-1-019} The latent heat exchange effectiveness at the \emph{heating} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 100\% of the nominal supply air flow rate. Specify this value as 0.0 if the heat exchanger does not transfer latent energy. The default value for this field is 0. -\paragraph{Field: Sensible Effectiveness at 75\% Heating Air Flow}\label{field-sensible-effectiveness-at-75-heating-air-flow} - -The sensible heat exchange effectiveness at the \emph{heating} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 75\% of the nominal supply air flow rate. The default value for this field is 0. - -\paragraph{Field: Latent Effectiveness at 75\% Heating Air Flow}\label{field-latent-effectiveness-at-75-heating-air-flow} - The latent heat exchange effectiveness at the \emph{heating} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 75\% of the nominal supply air flow rate. Specify this value as 0.0 if the heat exchanger does not transfer latent energy. The default value for this field is 0. \paragraph{Field: Sensible Effectiveness at 100\% Cooling Air Flow}\label{field-sensible-effectiveness-at-100-cooling-air-flow} @@ -280,14 +274,6 @@ \subsubsection{Inputs}\label{inputs-1-019} The latent heat exchange effectiveness at the \emph{cooling} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 100\% of the nominal supply air flow rate. Specify this value as 0.0 if the heat exchanger does not transfer latent energy. The default value for this field is 0. -\paragraph{Field: Sensible Effectiveness at 75\% Cooling Air Flow}\label{field-sensible-effectiveness-at-75-cooling-air-flow} - -The sensible heat exchange effectiveness at the \emph{cooling} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 75\% of the nominal supply air flow rate. The default value for this field is 0. - -\paragraph{Field: Latent Effectiveness at 75\% Cooling Air Flow}\label{field-latent-effectiveness-at-75-cooling-air-flow} - -The latent heat exchange effectiveness at the \emph{cooling} condition defined in Table~\ref{table:operating-conditions-for-defining-heat} with both the supply and exhaust air volume flow rates equal to 75\% of the nominal supply air flow rate. Specify this value as 0.0 if the heat exchanger does not transfer latent energy. The default value for this field is 0. - \paragraph{Field: Supply Air Inlet Node Name}\label{field-supply-air-inlet-node-name-1-000} The name of the HVAC system node from which the unit draws its supply (primary) inlet air. @@ -392,6 +378,22 @@ \subsubsection{Inputs}\label{inputs-1-019} This input denotes whether the heat exchanger unit is locked out (bypassed for plate type heat exchangers or the rotation is suspended for rotary type heat exchangers) when the air-side economizer is operating. Both the economizer and high humidity control (Ref. \hyperref[controlleroutdoorair]{Controller:OutdoorAir}) activate the heat exchanger lockout as specified by this input. The input choices are \emph{Yes} (meaning locked out) or \emph{No}. The default input for this field is Yes. +\paragraph{Field: Sensible Effectiveness of Heating Air Flow Curve Name}\label{field-sensible-effectiveness-of-heating-air-flow-curve-name-1} + +This optional input allows the user to specify a curve that determines the value of the sensible effectiveness for heating. The result of the curve is multipled by the sensible effectiveness at 100\% heating (see field: \hyperref[field-sensible-effectiveness-at-100-heating-air-flow]{Sensible Effectiveness at 100\% Heating Air Flow} above). + +\paragraph{Field: Latent Effectiveness of Heating Air Flow Curve Name}\label{field-latent-effectiveness-of-heating-air-flow-curve-name-1} + +This optional input allows the user to specify a curve that determines the value of the latent effectiveness for heating. The result of the curve is multipled by the latent effectiveness at 100\% heating (see field: \hyperref[field-latent-effectiveness-at-100-heating-air-flow]{Latent Effectiveness at 100\% Heating Air Flow} above). + +\paragraph{Field: Sensible Effectiveness of Cooling Air Flow Curve Name}\label{field-sensible-effectiveness-of-cooling-air-flow-curve-name-1} + +This optional input allows the user to specify a curve that determines the value of the sensible effectiveness for cooling. The result of the curve is multipled by the sensible effectiveness at 100\% cooling (see field: \hyperref[field-sensible-effectiveness-at-100-cooling-air-flow]{Sensible Effectiveness at 100\% Cooling Air Flow} above). + +\paragraph{Field: Latent Effectiveness of Cooling Air Flow Curve Name}\label{field-latent-effectiveness-of-cooling-air-flow-curve-name-1} + +This optional input allows the user to specify a curve that determines the value of the latent effectiveness for cooling. The result of the curve is multipled by the latent effectiveness at 100\% cooling (see field: \hyperref[field-latent-effectiveness-at-100-cooling-air-flow]{Latent Effectiveness at 100\% Cooling Air Flow} above). + Following is an example input for this heat exchanger object: \begin{lstlisting} diff --git a/doc/input-output-reference/src/overview/group-humidifiers-and-dehumidifiers.tex b/doc/input-output-reference/src/overview/group-humidifiers-and-dehumidifiers.tex index 512b5c8e245..07db612b013 100644 --- a/doc/input-output-reference/src/overview/group-humidifiers-and-dehumidifiers.tex +++ b/doc/input-output-reference/src/overview/group-humidifiers-and-dehumidifiers.tex @@ -209,9 +209,11 @@ \subsubsection{Inputs}\label{inputs-1-021} \item HVAC,Sum,Humidifier Water Volume{[}m3{]} \item - HVAC,Average,Humidifier Gas Use Rate{[}W{]} + HVAC,Average,Humidifier NaturalGas Use Rate{[}W{]} \item - HVAC,Sum,Humidifier Gas Use Energy {[}J{]} + HVAC,Sum,Humidifier NaturalGas Use Energy {[}J{]} + \item + HVAC,Average,Humidifier NaturalGas Use Thermal Efficiency {[}{]} \item HVAC,Average,Humidifier Auxiliary Electricity Rate {[}W{]} \item @@ -219,7 +221,7 @@ \subsubsection{Inputs}\label{inputs-1-021} \item HVAC,Meter,Humidifier:Water {[}m3{]} \item - HVAC,Meter,Humidifier:Gas {[}J{]} + HVAC,Meter,Humidifier:NaturalGas {[}J{]} \item HVAC,Meter,Humidifier:Electricity {[}J{]} \item @@ -244,13 +246,17 @@ \subsubsection{Inputs}\label{inputs-1-021} This output is the cubic meters of water consumed by the steam humidifier over the timestep being reported. -\paragraph{Humidifier Gas Use Rate {[}W{]}}\label{humidifier-gas-use-rate-w} +\paragraph{Humidifier NaturalGas Use Rate {[}W{]}}\label{humidifier-naturalgas-use-rate-w} -This output is the gas use rate of the gas fired steam humidifier in Watts. +This output is the natural gas use rate of the natural gas fired steam humidifier in Watts. -\paragraph{Humidifier Gas Use Energy {[}J{]}}\label{humidifier-gas-use-energy-j} +\paragraph{Humidifier NaturalGas Use Energy {[}J{]}}\label{humidifier-naturalgas-use-energy-j} -This output is the gas consumption of the gas fired steam humidifier in Joules. +This output is the natural gas consumption of the natural gas fired steam humidifier in Joules. + +\paragraph{Humidifier NaturalGas Use Thermal Efficiency {[}{]}}\label{humidifier-naturalgas-use-thermal-efficiency-j} + +This output is the thermal efficiency of the natural gas consumed by the natural gas fired steam humidifier. \paragraph{Humidifier Auxiliary Electricity Rate {[}W{]}}\label{humidifier-auxiliary-electric-power-w} @@ -264,9 +270,9 @@ \subsubsection{Inputs}\label{inputs-1-021} This meter output contains the sum of the water consumed (in cubic meters of water during the report timestep) by all the steam humidifiers at the HVAC level in the simulation. -\paragraph{Humidifier:Gas {[}J{]}}\label{humidifiergas-j} +\paragraph{Humidifier:NaturalGas {[}J{]}}\label{humidifiernaturalgas-j} -This meter output contains the sum of the gas consumed (in Joules during the report timestep) by all the steam humidifiers at the HVAC level in the simulation. +This meter output contains the sum of the natural gas consumed (in Joules during the report timestep) by all the steam humidifiers at the HVAC level in the simulation. \paragraph{Humidifier Storage Tank Water Volume Flow Rate {[}m3/s{]}}\label{humidifier-storage-tank-water-volume-flow-rate-m3s-1} diff --git a/doc/input-output-reference/src/overview/group-hybrid-model.tex b/doc/input-output-reference/src/overview/group-hybrid-model.tex index c110826c75b..19e806eb8f9 100644 --- a/doc/input-output-reference/src/overview/group-hybrid-model.tex +++ b/doc/input-output-reference/src/overview/group-hybrid-model.tex @@ -16,8 +16,9 @@ \subsubsection{Inputs}\label{inputs-hybridzone} \paragraph{Field: Calculate Zone Internal Thermal Mass}\label{field-calculate-zone-internal-thermal-mass-hm} -This field is used to provide an option to calculate the temperature capacity multiplier (Ref: ZoneCapacitanceMultiplier:ResearchSpecial). The temperature capacity multiplier is represented as internal thermal mass multiplier in the hybrid model. -When YES is selected, the hybrid model calculates the multiplier based on the inverse heat balance algorithm using the measured zone air temperature. +This field is used to provide an option to calculate the temperature capacity multiplier required by \hyperref[zonecapacitancemultiplierresearchspecial]{ZoneCapacitanceMultiplier:ResearchSpecial}. The temperature capacity multiplier is represented as internal thermal mass multiplier in the hybrid model. When YES is selected, the hybrid model calculates the multiplier based on the inverse heat balance algorithm using the measured zone air temperature. + +Output for this parameter can be found via the output variable listed below. Additionally, an average for the simulation is also provided in the table report \hyperref[input-verification-and-results-summary-or-ivrs]{Input Verification and Results Summary} subtable \textit{Hybrid Model: Internal Thermal Mass}. \paragraph{Field: Calculate Zone Air Infiltration Rate}\label{field-calculate-zone-air-infiltration-rate-hm} diff --git a/doc/input-output-reference/src/overview/group-performance-curves.tex b/doc/input-output-reference/src/overview/group-performance-curves.tex index 0675def13f5..37a96ce5ae7 100644 --- a/doc/input-output-reference/src/overview/group-performance-curves.tex +++ b/doc/input-output-reference/src/overview/group-performance-curves.tex @@ -164,6 +164,14 @@ \subsubsection{Inputs}\label{inputs-1-028} The maximum allowable value of z. Values of z greater than the maximum will be replaced by the maximum. +\paragraph{Field: Minimum Curve Output}\label{field-minimum-curve-output-quadlinear} + +The minimum allowable value of the evaluated curve. Values less than the minimum will be replaced by the minimum. + +\paragraph{Field: Maximum Curve Output}\label{field-maximum-curve-output-quadlinear} + +The maximum allowable value of the evaluated curve. Values greater than the maximum will be replaced by the maximum. + \paragraph{Field: Input Unit Type for w}\label{field-input-unit-type-for-w} This field is used to indicate the kind of units that may be associated with the w values. It is used by IDF Editor to display the appropriate SI and IP units for the Minimum Value of w and Maximum Value of w. The unit conversion is not applied to the coefficients. The available options are shown below. If none of these options are appropriate, select Dimensionless which will have no unit conversion. @@ -383,6 +391,14 @@ \subsubsection{Inputs}\label{inputs-2-050} The maximum allowable value of z. Values of z greater than the maximum will be replaced by the maximum. +\paragraph{Field: Minimum Curve Output}\label{field-minimum-curve-output-quintlinear} + +The minimum allowable value of the evaluated curve. Values less than the minimum will be replaced by the minimum. + +\paragraph{Field: Maximum Curve Output}\label{field-maximum-curve-output-quintlinear} + +The maximum allowable value of the evaluated curve. Values greater than the maximum will be replaced by the maximum. + \paragraph{Field: Input Unit Type for v}\label{field-input-unit-type-for-v} This field is used to indicate the kind of units that may be associated with the v values. It is used by IDF Editor to display the appropriate SI and IP units for the Minimum Value of v and Maximum Value of v. The unit conversion is not applied to the coefficients. The available options are shown below. If none of these options are appropriate, select Dimensionless which will have no unit conversion. diff --git a/doc/input-output-reference/src/overview/group-refrigeration.tex b/doc/input-output-reference/src/overview/group-refrigeration.tex index 8175fec2f57..df56baccbd7 100644 --- a/doc/input-output-reference/src/overview/group-refrigeration.tex +++ b/doc/input-output-reference/src/overview/group-refrigeration.tex @@ -3980,7 +3980,7 @@ \subsection{Refrigeration:AirChiller}\label{refrigerationairchiller} The Refrigeration:AirChiller object works in conjunction with a refrigeration chiller set, compressor rack, a refrigeration system, or a refrigeration secondary system object (Ref. ZoneHvac:RefrigerationChillerSet, and a \hyperref[refrigerationcompressorrack]{Refrigeration:CompressorRack}, \hyperref[refrigerationsystem]{Refrigeration:System}, or \hyperref[refrigerationsecondarysystem]{Refrigeration:SecondarySystem}) to simulate the performance of an air chiller, similar to one found in a refrigerated warehouse. The air chiller model uses information at rated conditions along with the zone conditions to determine performance. Energy use for fans and heaters is modeled based on inputs for nominal power, schedules, and control type. The refrigeration chiller model accounts for the sensible and latent heat exchange with the surrounding environment. -The refrigeration chiller cooler object inputs include a name, an availability schedule name, the rated cooling capacity, the rated operating temperature, the rated cooling source temperature, the rated total heating power and heating power schedule, the rated fan power and schedules, defrost type, defrost control type, defrost schedule name, drip-down schedule name, defrost power, the portion of the defrost energy used to melt ice (only for temperature termination control type), and refrigerant inventory. +The refrigeration chiller cooler object inputs include a name, an availability schedule name, the rated cooling capacity, the rated cooling source temperature, the rated total heating power and heating power schedule, the rated fan power and schedules, defrost type, defrost control type, defrost schedule name, drip-down schedule name, defrost power, the portion of the defrost energy used to melt ice (only for temperature termination control type), and refrigerant inventory. Chiller coils are rated under multiple conventions. Each rating is typically based upon a selected fin material and refrigerant cycle, with correction factors for other materials or refrigerants. Fields are provided here for those correction factors. The performance of all chiller coils depends upon the inlet air temperature, relative humidity, and flow rate. Multiple methods of expressing this relationship are provided here to accommodate the way information is provided by different manufacturers. @@ -3996,9 +3996,9 @@ \subsubsection{Inputs}\label{inputs-15-011} \paragraph{Field: Capacity Rating Type}\label{field-capacity-rating-type} -The type of capacity rating used for this refrigeration chiller. Valid choices are UnitLoadFactorSensibleOnly, CapacityTotalSpecificConditions, EuropeanSC1Standard, EuropeanSC1NominalWet, EuropeanSC2Standard, EuropeanSC2NominalWet, EuropeanSC3Standard, EuropeanSC3NominalWet, EuropeanSC4Standard, EuropeanSC4NominalWet, EuropeanSC5Standard, and EuropeanSC5NominalWet. In each case, select the rating option that corresponds to the expected service conditions.~ For example, U.S. manufacturers quote a separate Unit Load Factor for wet or frosted coils.~ If the evaporating temperature is less than 0C, input the frosted coil value. Within the European convention, select SC1, 2, 3, 4, or 5 depending upon the expected evaporating temperature. This field is required and there is no default value. Refer to the Engineering Reference for further information on these rating types. NOTE: If the CapacityTotalSpecificConditions rating type is specified, the input file must include the manufacturer's coil capacity correction curve in tabular form using the \hyperref[tablelookup]{Table:Lookup} object. An example of this may be found in the RefrigeratedWarehouse.idf example file. +The type of capacity rating used for this refrigeration chiller. Valid choices are UnitLoadFactorSensibleOnly, CapacityTotalSpecificConditions, EuropeanSC1Standard, EuropeanSC1NominalWet, EuropeanSC2Standard, EuropeanSC2NominalWet, EuropeanSC3Standard, EuropeanSC3NominalWet, EuropeanSC4Standard, EuropeanSC4NominalWet, EuropeanSC5Standard, and EuropeanSC5NominalWet. In each case, select the rating option that corresponds to the expected service conditions.~ For example, U.S. manufacturers quote a separate Unit Load Factor for wet or frosted coils.~ If the evaporating temperature is less than 0C, input the frosted coil value. Within the European convention, select SC1, 2, 3, 4, or 5 depending upon the expected evaporating temperature. This field is required and there is no default value. Refer to the Engineering Reference for further information on these rating types. NOTE: If the CapacityTotalSpecificConditions rating type is specified, the input file must include the manufacturer's coil capacity correction curve in tabular form using the \hyperref[tablelookup]{Table:Lookup} object. An example of this may be found in the RefrigeratedWarehouse.idf example file. Based on this field, only one of the next two fields should be entered. -\paragraph{NOTE -- ONLY ONE OF THE FOLLOWING TWO FIELDS IS USED}\label{note-only-one-of-the-following-two-fields-is-used} +\textbf{\emph{NOTE: only one of the following two fields is used and which field is required is dependent on the value given to the Capacity Rating Type field.}} \paragraph{Field: Rated Unit Load Factor}\label{field-rated-unit-load-factor} diff --git a/doc/input-output-reference/src/overview/group-setpoint-managers.tex b/doc/input-output-reference/src/overview/group-setpoint-managers.tex index 5f0ffdb8a6b..188f0ef3741 100644 --- a/doc/input-output-reference/src/overview/group-setpoint-managers.tex +++ b/doc/input-output-reference/src/overview/group-setpoint-managers.tex @@ -528,7 +528,7 @@ \subsubsection{Inputs}\label{inputs-7-024} \subsection{SetpointManager:MixedAir}\label{setpointmanagermixedair} -The Mixed Air Setpoint Manager is meant to be used in conjunction with a \hyperref[controlleroutdoorair]{Controller:OutdoorAir} object. This setpoint manager is used to establish a temperature setpoint at the mixed air node. The \hyperref[controlleroutdoorair]{Controller:OutdoorAir} then operates the outdoor air damper to attempt to meet this setpoint. +The Mixed Air Setpoint Manager is meant to be used in conjunction with a \hyperref[controlleroutdoorair]{Controller:OutdoorAir} object. This setpoint manager is used to establish temperature setpoints for any component with a control node that is upstream of the fan. An example of the use of this setpoint manager might be to define a temperature setpoint at the mixed air node. The \hyperref[controlleroutdoorair]{Controller:OutdoorAir} then operates the outdoor air damper in an attempt to meet this setpoint. In EnergyPlus the relief and outdoor air dampers, the economizer, and any outdoor air conditioning equipment form a separate subsystem of an air loop system (ref. \hyperref[airloophvac]{AirLoopHVAC}). The outdoor air controller operates within the subsystem. Consequently the mixed air temperature setpoint must take into account any downstream system fan heat if it is to meet a desired system supply air leaving temperature. The Mixed Air Setpoint Manager accomplishes this by referencing a supply air setpoint set by another setpoint manager (most likely at the \hyperref[airloophvac]{AirLoopHVAC} outlet node). The supply fan inlet and outlet nodes are also inputs to the Mixed Air Setpoint Manager. From this information the Mixed Air Setpoint Manager calculates the supply fan air temperature rise, subtracts it from the reference setpoint temperature, and sets the result as the mixed air node setpoint temperature. diff --git a/doc/input-output-reference/src/overview/group-water-systems.tex b/doc/input-output-reference/src/overview/group-water-systems.tex index c8ef7a8a407..b2d62ca2a97 100644 --- a/doc/input-output-reference/src/overview/group-water-systems.tex +++ b/doc/input-output-reference/src/overview/group-water-systems.tex @@ -7,7 +7,7 @@ \section{Group Water Systems}\label{group-water-systems} In addition to the input objects described in this section below, there are a variety of HVAC components that can be configured to interact with the water systems. These component input objects include optional fields that allow describing how the water systems are connected to them by providing the name of a storage tank. The following table lists EnergyPlus input objects that include provisions for connecting to the water systems but are described elsewhere in this document: % table 34 -\begin{longtable}[c]{p{2.49in}p{3.5in}} +\begin{longtable}[c]{p{3.5in}p{3.5in}} \caption{Water Systems Objects \label{table:water-systems-objects}} \tabularnewline \toprule Input Object Name & Type of Water Interactions \tabularnewline diff --git a/doc/input-output-reference/src/parametric-objects.tex b/doc/input-output-reference/src/parametric-objects.tex index f459b691789..e8bbfb2dc74 100644 --- a/doc/input-output-reference/src/parametric-objects.tex +++ b/doc/input-output-reference/src/parametric-objects.tex @@ -43,7 +43,7 @@ \section{Group -- Parametrics}\label{group-parametrics} A new IDF file is created for each of these simulations and is named the original name of the file plus either a number or a user defined suffix (if \hyperref[parametricfilenamesuffix]{Parametric:FileNameSuffix} is used). Looking at how these created IDF files show the substituted values can help understand problems that may occur. -The `` = \$insDepth'' is a simple substation but could also be a more complex expression involving operators and predefined functions such as +The `` = \$insDepth'' is a simple substitution but could also be a more complex expression involving operators and predefined functions such as ~ = \$insDepth * 1.1 + 0.0004 * SQRT(12) @@ -51,7 +51,7 @@ \section{Group -- Parametrics}\label{group-parametrics} \subsection{Expressions}\label{expressions} -Expressions can occur anywhere in the IDF file as a field value if the expression begins with an equals sign ( = ) and can also occur in assignment statements in the \hyperref[parametriclogic]{Parametric:Logic} object. The operators include: +, -, *, /, \^{} (exponent), \&\& (and), \textbar{}\textbar{} (or), = = , \textgreater{}, \textless{}, \textless{} = , \textgreater{} = ,~ \textless{}\textgreater{}, and //. These are computed using standard operator precedence rules. The parenthesis are used to execute sub-expressions with higher precedence. Some built in functions, such as ABS, ACOS, ASIN, ATAN, COS, EXP, INT, LEN, LOG, MOD, NOT, SIN, SQRT, TAN are supported in expressions. Theses built in functions all take a single argument. +Expressions can occur anywhere in the IDF file as a field value if the expression begins with an equals sign ( = ) and can also occur in assignment statements in the \hyperref[parametriclogic]{Parametric:Logic} object. The operators include: +, -, *, /, \^{} (exponent), \&\& (and), \textbar{}\textbar{} (or), = = , \textgreater{}, \textless{}, \textless{} = , \textgreater{} = ,~ \textless{}\textgreater{}, and //. These are computed using standard operator precedence rules. The parenthesis are used to execute sub-expressions with higher precedence. Some built in functions, such as ABS, ACOS, ASIN, ATAN, COS, EXP, INT, LEN, LOG, MOD, NOT, SIN, SQRT, TAN are supported in expressions. These built-in functions all take a single argument. \subsection{Processing Order}\label{processing-order} @@ -97,7 +97,7 @@ \subsubsection{Inputs}\label{inputs-030} \paragraph{Field: Value for run n}\label{field-value-for-run-n} -The value that should be substituted for the parameter on the n-th simulation. If multiple Parametric:SetValueForRun objects exist and they have different number of fields, the last field value will be used for the remaining field values. This means that to set all values the same, only the first value needed to be entered. +The value that should be substituted for the parameter on the n-th simulation. If multiple Parametric:SetValueForRun objects exist and they have different number of fields, the last field value will be used for the remaining field values. This means that to set all values the same, only the first value needs to be entered. \subsection{Parametric:Logic}\label{parametriclogic} diff --git a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex index 664a293c151..27fe7e4acd8 100644 --- a/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex +++ b/doc/input-output-reference/src/standard-output-reports/output-table-summaryreports.tex @@ -47,7 +47,7 @@ \subsubsection{Predefined Annual Summary Reports}\label{predefined-annual-summar \item Zone Summary includes internal load summary for each zone including area, if conditioned, volume, multipliers, above ground gross wall area, underground gross wall area, window area, design lighting, design people, and design plug and process. \item - Hybrid Model: Internal Thermal Mass table is only shown when hybrid model: internal thermal mass simulation. This includes Hybrid Modeling (Y/N) for internal mass and Temperature Capacitance Multiplier values for each zone. + Hybrid Model: Internal Thermal Mass table is only shown when the field \textit{Calculate Zone Internal Mass} is set to YES in the \hyperref[inputs-hm]{HybridModel:Zone} object. This report includes Hybrid Modeling for Internal Mass and Temperature Capacitance Multiplier values for each zone. \end{itemize} \paragraph{Source Energy End Use Components Summary}\label{source-energy-end-use-components-summary} diff --git a/testfiles/HybridZoneModel.idf b/testfiles/HybridZoneModel.idf index 57708272fb7..5e9eebad51f 100644 --- a/testfiles/HybridZoneModel.idf +++ b/testfiles/HybridZoneModel.idf @@ -188,7 +188,7 @@ HybridModel:Zone, ZONE 1 HybridModel, !- Name ZONE 1, !- Zone Name - NO, !- Calculate Zone Internal Thermal Mass + YES, !- Calculate Zone Internal Thermal Mass NO, !- Calculate Zone Air Infiltration Rate NO, !- Calculate Zone People Count ZONE 1_MeasuredTemperature, !- Zone Measured Air Temperature Schedule Name @@ -325,6 +325,8 @@ Output:VariableDictionary,regular; + Output:Table:SummaryReports,InputVerificationandResultsSummary; + Output:Variable,ZONE 2,Zone Infiltration Hybrid Model Air Change Rate,Timestep; Output:Variable,*,Zone Mean Air Temperature,Timestep; From b26ef00d4764bdac2acf2b63fe0175a69e729dd2 Mon Sep 17 00:00:00 2001 From: Rick Strand Date: Fri, 12 Jul 2024 09:57:25 -0500 Subject: [PATCH 102/115] Another update for 9972 Another doc mod request. Fixed as per suggestion from @mjwitte --- .../src/overview/group-electric-load-center-generator.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex b/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex index 6d606097bcd..c36ba22bab5 100644 --- a/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex +++ b/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex @@ -4451,7 +4451,7 @@ \subsubsection{Inputs}\label{inputs-20-000} \paragraph{Field: Surface Name}\label{field-surface-name-001} -This field is the name of a surface that defines the location and geometry of the array. +This field is the name of a surface that defines the location and geometry of the array. Array tilt, azimuth, and gross area are taken from the referenced building surface or shading surface. This will define the orientation of the solar panel for the detailed models and also the area of the solar panel for the simple model. \paragraph{Field: Photovoltaic Performance Object Type}\label{field-photovoltaic-performance-object-type} From 9f4ddce49ec1e600121ae405df6841840333781d Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Fri, 12 Jul 2024 11:51:28 -0500 Subject: [PATCH 103/115] Apply clang format --- src/EnergyPlus/DataGlobalConstants.hh | 9 ++-- src/EnergyPlus/api/datatransfer.cc | 59 ++++++++------------------- 2 files changed, 22 insertions(+), 46 deletions(-) diff --git a/src/EnergyPlus/DataGlobalConstants.hh b/src/EnergyPlus/DataGlobalConstants.hh index 9dd322d6bfa..5b621709241 100644 --- a/src/EnergyPlus/DataGlobalConstants.hh +++ b/src/EnergyPlus/DataGlobalConstants.hh @@ -474,14 +474,15 @@ namespace Constant { "customEMS" // customEMS }; - inline std::string unitToString(Units unit) { + inline std::string unitToString(Units unit) + { switch (unit) { case Units::Invalid: return "invalid"; default: - if (!(0 <= (int)unit - && (int)unit < (int)unitNames.size())) - { return "invalid-out-of-range"; } + if (!(0 <= (int)unit && (int)unit < (int)unitNames.size())) { + return "invalid-out-of-range"; + } return std::string{unitNames[(unsigned int)unit]}; } return ""; diff --git a/src/EnergyPlus/api/datatransfer.cc b/src/EnergyPlus/api/datatransfer.cc index 276b37f67c0..3ab99d07e25 100644 --- a/src/EnergyPlus/api/datatransfer.cc +++ b/src/EnergyPlus/api/datatransfer.cc @@ -52,8 +52,8 @@ #include #include -#include #include +#include #include #include #include @@ -83,31 +83,17 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) std::vector localDataEntries; auto *thisState = reinterpret_cast(state); for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { - if (availActuator.ComponentTypeName.empty() - && availActuator.UniqueIDName.empty() - && availActuator.ControlTypeName.empty()) - { + if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { break; } localDataEntries.emplace_back( - "Actuator", - availActuator.ComponentTypeName, - availActuator.ControlTypeName, - availActuator.UniqueIDName, - availActuator.Units - ); + "Actuator", availActuator.ComponentTypeName, availActuator.ControlTypeName, availActuator.UniqueIDName, availActuator.Units); } for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { if (availVariable.DataTypeName.empty() && availVariable.UniqueIDName.empty()) { break; } - localDataEntries.emplace_back( - "InternalVariable", - availVariable.DataTypeName, - "", - availVariable.UniqueIDName, - availVariable.Units - ); + localDataEntries.emplace_back("InternalVariable", availVariable.DataTypeName, "", availVariable.UniqueIDName, availVariable.Units); } for (auto const &gVarName : thisState->dataPluginManager->globalVariableNames) { localDataEntries.emplace_back("PluginGlobalVariable", "", "", gVarName, ""); @@ -119,28 +105,20 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) if (meter->Name.empty()) { break; } - localDataEntries.emplace_back( - "OutputMeter", - "", - "", - meter->Name, - EnergyPlus::Constant::unitToString(meter->units) - ); + localDataEntries.emplace_back("OutputMeter", "", "", meter->Name, EnergyPlus::Constant::unitToString(meter->units)); } for (auto const *variable : thisState->dataOutputProcessor->outVars) { if (variable->varType != EnergyPlus::OutputProcessor::VariableType::Real) continue; if (variable->name.empty() && variable->keyUC.empty()) { break; } - localDataEntries.emplace_back( - "OutputVariable", - variable->name, - "", - variable->keyUC, - variable->units == EnergyPlus::Constant::Units::customEMS - ? variable->unitNameCustomEMS - : EnergyPlus::Constant::unitToString(variable->units) - ); + localDataEntries.emplace_back("OutputVariable", + variable->name, + "", + variable->keyUC, + variable->units == EnergyPlus::Constant::Units::customEMS + ? variable->unitNameCustomEMS + : EnergyPlus::Constant::unitToString(variable->units)); } *resultingSize = localDataEntries.size(); auto *data = new APIDataEntry[*resultingSize]; @@ -212,9 +190,7 @@ char *listAllAPIDataCSV(EnergyPlusState state) } output.append("OutputMeter").append(","); output.append(meter->Name).append(","); - output.append( - EnergyPlus::Constant::unitToString(meter->units) - ).append("\n"); + output.append(EnergyPlus::Constant::unitToString(meter->units)).append("\n"); } output.append("**VARIABLES**\n"); for (auto const *variable : thisState->dataOutputProcessor->outVars) { @@ -225,11 +201,10 @@ char *listAllAPIDataCSV(EnergyPlusState state) output.append("OutputVariable,"); output.append(variable->name).append(","); output.append(variable->keyUC).append(","); - output.append( - variable->units == EnergyPlus::Constant::Units::customEMS - ? variable->unitNameCustomEMS - : EnergyPlus::Constant::unitToString(variable->units) - ).append("\n"); + output + .append(variable->units == EnergyPlus::Constant::Units::customEMS ? variable->unitNameCustomEMS + : EnergyPlus::Constant::unitToString(variable->units)) + .append("\n"); } // note that we cannot just return a c_str to the local string, as the string will be destructed upon leaving // this function, and undefined behavior will occur. From 3d2f0852efb6bba3c12364a1c158b3ab848665b9 Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Fri, 12 Jul 2024 12:55:48 -0500 Subject: [PATCH 104/115] IDE cleanups in data transfer API file, should not be any functional change --- src/EnergyPlus/api/datatransfer.cc | 636 ++++++++++++-------------- src/EnergyPlus/api/datatransfer.h | 2 +- tst/EnergyPlus/api/TestDataTransfer.c | 7 + 3 files changed, 307 insertions(+), 338 deletions(-) diff --git a/src/EnergyPlus/api/datatransfer.cc b/src/EnergyPlus/api/datatransfer.cc index 3ab99d07e25..a459c0a7cc2 100644 --- a/src/EnergyPlus/api/datatransfer.cc +++ b/src/EnergyPlus/api/datatransfer.cc @@ -60,7 +60,7 @@ #include #include #include -#include +// #include #include #include #include @@ -81,7 +81,7 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) } }; std::vector localDataEntries; - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { break; @@ -137,7 +137,7 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) return data; } -void freeAPIData(struct APIDataEntry *data, unsigned int arraySize) +void freeAPIData(const APIDataEntry *data, const unsigned int arraySize) { for (unsigned int i = 0; i < arraySize; i++) { delete[] data[i].what; @@ -151,7 +151,7 @@ void freeAPIData(struct APIDataEntry *data, unsigned int arraySize) char *listAllAPIDataCSV(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); std::string output = "**ACTUATORS**\n"; for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { @@ -217,7 +217,7 @@ char *listAllAPIDataCSV(EnergyPlusState state) int apiDataFullyReady(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); if (thisState->dataPluginManager->fullyReady) { return 1; } @@ -226,25 +226,24 @@ int apiDataFullyReady(EnergyPlusState state) int apiErrorFlag(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); if (thisState->dataPluginManager->apiErrorFlag) { return 1; - } else { - return 0; } + return 0; } void resetErrorFlag(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); thisState->dataPluginManager->apiErrorFlag = false; } const char **getObjectNames(EnergyPlusState state, const char *objectType, unsigned int *resultingSize) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); auto &epjson = thisState->dataInputProcessing->inputProcessor->epJSON; - auto instances = epjson.find(objectType); + const auto instances = epjson.find(objectType); if (instances == epjson.end()) { *resultingSize = 0; return nullptr; @@ -269,7 +268,7 @@ void freeObjectNames(const char **objectNames, unsigned int arraySize) int getNumNodesInCondFDSurfaceLayer(EnergyPlusState state, const char *surfName, const char *matName) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); std::string UCsurfName = EnergyPlus::Util::makeUPPER(surfName); std::string UCmatName = EnergyPlus::Util::makeUPPER(matName); return EnergyPlus::HeatBalFiniteDiffManager::numNodesInMaterialLayer(*thisState, UCsurfName, UCmatName); @@ -280,7 +279,7 @@ void requestVariable(EnergyPlusState state, const char *type, const char *key) // allow specifying a request for an output variable, so that E+ does not have to keep all of them in memory // should be called before energyplus is run! // note that the variable request array is cleared during clear_state, so if you run multiple E+ runs, these must be requested again each time. - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); EnergyPlus::OutputProcessor::APIOutputVariableRequest request; request.varName = type; request.varKey = key; @@ -298,10 +297,10 @@ int getVariableHandle(EnergyPlusState state, const char *type, const char *key) // - index N+M being the highest integer variable handle // In this function, it is as simple as looping over both types and continuing to increment // the handle carefully. In the getValue function it is just a matter of checking array sizes. - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); std::string const typeUC = EnergyPlus::Util::makeUPPER(type); std::string const keyUC = EnergyPlus::Util::makeUPPER(key); - for (int i = 0; i < (int)thisState->dataOutputProcessor->outVars.size(); i++) { + for (int i = 0; i < thisState->dataOutputProcessor->outVars.size(); i++) { auto const *var = thisState->dataOutputProcessor->outVars[i]; if (typeUC == var->nameUC && keyUC == var->keyUC) { return i; @@ -319,76 +318,73 @@ Real64 getVariableValue(EnergyPlusState state, const int handle) // - index N+1 being the first integer variable handle // - index N+M being the highest integer variable handle // note that this function will return -1 if it cannot - auto *thisState = reinterpret_cast(state); - if (handle >= 0 && handle < (int)thisState->dataOutputProcessor->outVars.size()) { + auto *thisState = static_cast(state); + if (handle >= 0 && handle < thisState->dataOutputProcessor->outVars.size()) { auto const *thisOutputVar = thisState->dataOutputProcessor->outVars[handle]; if (thisOutputVar->varType == EnergyPlus::OutputProcessor::VariableType::Real) { return *(dynamic_cast(thisOutputVar))->Which; - } else if (thisOutputVar->varType == EnergyPlus::OutputProcessor::VariableType::Integer) { + } + if (thisOutputVar->varType == EnergyPlus::OutputProcessor::VariableType::Integer) { return (Real64) * (dynamic_cast(thisOutputVar))->Which; - } else { - if (thisState->dataGlobal->errorCallback) { - std::cout - << "ERROR: Variable at handle has type other than Real or Integer, returning zero but caller should take note and likely abort." - << std::endl; - } else { - // must be running from python plugin, need to fatal out once the plugin is done - // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Error in getVariableValue; received handle: {}", handle)); - EnergyPlus::ShowContinueError( - *thisState, "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); - } - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } - } else { if (thisState->dataGlobal->errorCallback) { - std::cout << "ERROR: Variable handle out of range in getVariableValue, returning zero but caller should take note and likely abort." - << std::endl; + std::cout + << "ERROR: Variable at handle has type other than Real or Integer, returning zero but caller should take note and likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getVariableValue; received handle: {}", handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Error in getVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( *thisState, "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } + if (thisState->dataGlobal->errorCallback) { + std::cout << "ERROR: Variable handle out of range in getVariableValue, returning zero but caller should take note and likely abort." + << std::endl; + } else { + // must be running from python plugin, need to fatal out once the plugin is done + // throw an error, set the fatal flag, and then return zero + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getVariableValue; received handle: {}", handle)); + EnergyPlus::ShowContinueError( + *thisState, "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + } + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int getMeterHandle(EnergyPlusState state, const char *meterName) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); std::string const meterNameUC = EnergyPlus::Util::makeUPPER(meterName); - int i = EnergyPlus::GetMeterIndex(*thisState, meterNameUC); + const int i = EnergyPlus::GetMeterIndex(*thisState, meterNameUC); if (i == 0) { // inside E+, zero is meaningful, but through the API, I want to use negative one as a signal of a bad lookup return -1; - } else { - return i; } + return i; } Real64 getMeterValue(EnergyPlusState state, int handle) { - auto *thisState = reinterpret_cast(state); - if (handle >= 0 && handle < (int)thisState->dataOutputProcessor->meters.size()) { + auto *thisState = static_cast(state); + if (handle >= 0 && handle < thisState->dataOutputProcessor->meters.size()) { return EnergyPlus::GetCurrentMeterValue(*thisState, handle); + } + if (thisState->dataGlobal->errorCallback) { + std::cout << "ERROR: Meter handle out of range in getMeterValue, returning zero but caller should take note and likely abort." + << std::endl; } else { - if (thisState->dataGlobal->errorCallback) { - std::cout << "ERROR: Meter handle out of range in getMeterValue, returning zero but caller should take note and likely abort." - << std::endl; - } else { - // must be running from python plugin, need to fatal out once the plugin is done - // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getMeterValue; received handle: {}", handle)); - EnergyPlus::ShowContinueError( - *thisState, "The getMeterValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); - } - thisState->dataPluginManager->apiErrorFlag = true; - return 0; + // must be running from python plugin, need to fatal out once the plugin is done + // throw an error, set the fatal flag, and then return zero + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getMeterValue; received handle: {}", handle)); + EnergyPlus::ShowContinueError( + *thisState, "The getMeterValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int getActuatorHandle(EnergyPlusState state, const char *componentType, const char *controlType, const char *uniqueKey) @@ -397,7 +393,7 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch std::string const typeUC = EnergyPlus::Util::makeUPPER(componentType); std::string const keyUC = EnergyPlus::Util::makeUPPER(uniqueKey); std::string const controlUC = EnergyPlus::Util::makeUPPER(controlType); - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); for (int ActuatorLoop = 1; ActuatorLoop <= thisState->dataRuntimeLang->numEMSActuatorsAvailable; ++ActuatorLoop) { auto &availActuator = thisState->dataRuntimeLang->EMSActuatorAvailable(ActuatorLoop); handle++; @@ -416,7 +412,7 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch "Data Exchange API: An EnergyManagementSystem:Actuator seems to be already defined in the EnergyPlus File and named '" + usedActuator.Name + "'."); EnergyPlus::ShowContinueError( - *thisState, "Occurred for componentType='" + typeUC + "', controlType='" + controlUC + "', uniqueKey='" + keyUC + "'."); + *thisState, fmt::format("Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", typeUC, controlUC, keyUC)); EnergyPlus::ShowContinueError(*thisState, fmt::format("The getActuatorHandle function will still return the handle (= {}) but caller " "should take note that there is a risk of overwritting.", @@ -429,7 +425,7 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch EnergyPlus::ShowWarningError(*thisState, "Data Exchange API: You seem to already have tried to get an Actuator Handle on this one."); EnergyPlus::ShowContinueError( - *thisState, "Occurred for componentType='" + typeUC + "', controlType='" + controlUC + "', uniqueKey='" + keyUC + "'."); + *thisState, fmt::format("Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", typeUC, controlUC, keyUC)); EnergyPlus::ShowContinueError(*thisState, fmt::format("The getActuatorHandle function will still return the handle (= {}) but caller should " "take note that there is a risk of overwritting.", @@ -447,9 +443,9 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch void resetActuator(EnergyPlusState state, int handle) { // resets the actuator so that E+ will use the internally calculated value again - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { - auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); + const auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); *theActuator.Actuated = false; } else { if (thisState->dataGlobal->errorCallback) { @@ -467,13 +463,13 @@ void resetActuator(EnergyPlusState state, int handle) void setActuatorValue(EnergyPlusState state, const int handle, const Real64 value) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); if (theActuator.RealValue) { *theActuator.RealValue = value; } else if (theActuator.IntValue) { - *theActuator.IntValue = (int)std::lround(value); + *theActuator.IntValue = static_cast(std::lround(value)); } else { // follow protocol from EMS manager, where 1.0 is true, 0.0 is false, and anything else is also false *theActuator.LogValue = value > 0.99999 && value < 1.00001; // allow small tolerance while passing between languages and types @@ -496,35 +492,33 @@ void setActuatorValue(EnergyPlusState state, const int handle, const Real64 valu Real64 getActuatorValue(EnergyPlusState state, const int handle) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { - auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); + const auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); if (theActuator.RealValue) { return *theActuator.RealValue; - } else if (theActuator.IntValue) { - return (float)*theActuator.IntValue; - } else { - // follow protocol from EMS manager, where 1.0 is true, 0.0 is false, and anything else is also false - if (*theActuator.LogValue) { - return 1; - } else { - return 0; - } } - } else { - if (thisState->dataGlobal->errorCallback) { - std::cout << "ERROR: Actuator handle out of range in getActuatorValue, returning zero but caller should take note and likely abort." - << std::endl; - } else { - // must be running from python plugin, need to fatal out once the plugin is done - // throw an error, set the fatal flag, and then return 0 - EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: index error in getActuatorValue; received handle: {}", handle)); - EnergyPlus::ShowContinueError( - *thisState, "The getActuatorValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + if (theActuator.IntValue) { + return static_cast(*theActuator.IntValue); + } + // follow protocol from EMS manager, where 1.0 is true, 0.0 is false, and anything else is also false + if (*theActuator.LogValue) { + return 1; } - thisState->dataPluginManager->apiErrorFlag = true; return 0; } + if (thisState->dataGlobal->errorCallback) { + std::cout << "ERROR: Actuator handle out of range in getActuatorValue, returning zero but caller should take note and likely abort." + << std::endl; + } else { + // must be running from python plugin, need to fatal out once the plugin is done + // throw an error, set the fatal flag, and then return 0 + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: index error in getActuatorValue; received handle: {}", handle)); + EnergyPlus::ShowContinueError( + *thisState, "The getActuatorValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + } + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int getInternalVariableHandle(EnergyPlusState state, const char *type, const char *key) @@ -532,7 +526,7 @@ int getInternalVariableHandle(EnergyPlusState state, const char *type, const cha int handle = 0; std::string const typeUC = EnergyPlus::Util::makeUPPER(type); std::string const keyUC = EnergyPlus::Util::makeUPPER(key); - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { // TODO: this should stop at numEMSInternalVarsAvailable handle++; std::string const variableTypeUC = EnergyPlus::Util::makeUPPER(availVariable.DataTypeName); @@ -546,47 +540,46 @@ int getInternalVariableHandle(EnergyPlusState state, const char *type, const cha Real64 getInternalVariableValue(EnergyPlusState state, int handle) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle >= 1 && handle <= (int)thisState->dataRuntimeLang->numEMSInternalVarsAvailable) { auto const &thisVar = thisState->dataRuntimeLang->EMSInternalVarsAvailable(handle); if (thisVar.PntrVarTypeUsed == EnergyPlus::DataRuntimeLanguage::PtrDataType::Real) { return *thisVar.RealValue; - } else if (thisVar.PntrVarTypeUsed == EnergyPlus::DataRuntimeLanguage::PtrDataType::Integer) { - return (Real64)(*thisVar.IntValue); - } else { - // Doesn't look like this struct actually has a logical member type, so uh, throw here? - std::cout << "ERROR: Invalid internal variable type here, developer issue., returning zero but caller should take note and likely abort." - << std::endl; - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } - } else { - if (thisState->dataGlobal->errorCallback) { - std::cout << "ERROR: Internal variable handle out of range in getInternalVariableValue, returning zero but caller should take note and " - "likely abort." - << std::endl; - } else { - // must be running from python plugin, need to fatal out once the plugin is done - // throw an error, set the fatal flag, and then return 0 - EnergyPlus::ShowSevereError(*thisState, - fmt::format("Data Exchange API: index error in getInternalVariableValue; received handle: {}", handle)); - EnergyPlus::ShowContinueError( - *thisState, "The getInternalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + if (thisVar.PntrVarTypeUsed == EnergyPlus::DataRuntimeLanguage::PtrDataType::Integer) { + return (Real64)(*thisVar.IntValue); } + // Doesn't look like this struct actually has a logical member type, so uh, throw here? + std::cout << "ERROR: Invalid internal variable type here, developer issue., returning zero but caller should take note and likely abort." + << std::endl; thisState->dataPluginManager->apiErrorFlag = true; return 0; } + if (thisState->dataGlobal->errorCallback) { + std::cout << "ERROR: Internal variable handle out of range in getInternalVariableValue, returning zero but caller should take note and " + "likely abort." + << std::endl; + } else { + // must be running from python plugin, need to fatal out once the plugin is done + // throw an error, set the fatal flag, and then return 0 + EnergyPlus::ShowSevereError(*thisState, + fmt::format("Data Exchange API: index error in getInternalVariableValue; received handle: {}", handle)); + EnergyPlus::ShowContinueError( + *thisState, "The getInternalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + } + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int getPluginGlobalVariableHandle(EnergyPlusState state, const char *name) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); return thisState->dataPluginManager->pluginManager->getGlobalVariableHandle(*thisState, name); } Real64 getPluginGlobalVariableValue(EnergyPlusState state, int handle) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxGlobalVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return 0 @@ -602,7 +595,7 @@ Real64 getPluginGlobalVariableValue(EnergyPlusState state, int handle) void setPluginGlobalVariableValue(EnergyPlusState state, int handle, Real64 value) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxGlobalVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -617,13 +610,13 @@ void setPluginGlobalVariableValue(EnergyPlusState state, int handle, Real64 valu int getPluginTrendVariableHandle(EnergyPlusState state, const char *name) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); return EnergyPlus::PluginManagement::PluginManager::getTrendVariableHandle(*thisState, name); } Real64 getPluginTrendVariableValue(EnergyPlusState state, int handle, int timeIndex) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -634,7 +627,7 @@ Real64 getPluginTrendVariableValue(EnergyPlusState state, int handle, int timeIn thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (timeIndex < 1 || timeIndex > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (timeIndex < 1 || timeIndex > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -651,7 +644,7 @@ Real64 getPluginTrendVariableValue(EnergyPlusState state, int handle, int timeIn Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int count) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -662,7 +655,7 @@ Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int coun thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -680,7 +673,7 @@ Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int coun Real64 getPluginTrendVariableMin(EnergyPlusState state, int handle, int count) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -691,7 +684,7 @@ Real64 getPluginTrendVariableMin(EnergyPlusState state, int handle, int count) thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -708,7 +701,7 @@ Real64 getPluginTrendVariableMin(EnergyPlusState state, int handle, int count) Real64 getPluginTrendVariableMax(EnergyPlusState state, int handle, int count) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -719,7 +712,7 @@ Real64 getPluginTrendVariableMax(EnergyPlusState state, int handle, int count) thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -736,7 +729,7 @@ Real64 getPluginTrendVariableMax(EnergyPlusState state, int handle, int count) Real64 getPluginTrendVariableSum(EnergyPlusState state, int handle, int count) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -747,7 +740,7 @@ Real64 getPluginTrendVariableSum(EnergyPlusState state, int handle, int count) thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -764,7 +757,7 @@ Real64 getPluginTrendVariableSum(EnergyPlusState state, int handle, int count) Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int count) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return @@ -775,7 +768,7 @@ Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int co thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > ((int)EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle))) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -793,133 +786,132 @@ Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int co int year(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->Year; } int calendarYear(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataGlobal->CalendarYear; } int month(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->Month; } int dayOfMonth(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfMonth; } int dayOfWeek(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfWeek; } int dayOfYear(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfYear; } int daylightSavingsTimeIndicator(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->DSTIndicator; } int hour(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataGlobal->HourOfDay - 1; // no, just stay on 0..23+ DSTadjust ! offset by 1 and daylight savings time } Real64 currentTime(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); if (thisState->dataHVACGlobal->TimeStepSys < thisState->dataGlobal->TimeStepZone) { // CurrentTime is for end of zone timestep, need to move back to beginning of current zone timestep, then add on system time elapsed already // plus current system timestep return thisState->dataGlobal->CurrentTime - thisState->dataGlobal->TimeStepZone + thisState->dataHVACGlobal->SysTimeElapsed + thisState->dataHVACGlobal->TimeStepSys; - } else { - return thisState->dataGlobal->CurrentTime; } + return thisState->dataGlobal->CurrentTime; } int minutes(EnergyPlusState state) { // the -1 is to push us to the right minute, but this should be handled cautiously because if we are inside the HVAC iteration loop, // currentTime() returns a floating point fractional hour, so truncation could put this a few seconds from the expected minute. - Real64 currentTimeVal = currentTime(state); - auto *thisState = reinterpret_cast(state); - Real64 fractionalHoursIntoTheDay = currentTimeVal - double(thisState->dataGlobal->HourOfDay - 1); - Real64 fractionalMinutesIntoTheDay = std::round(fractionalHoursIntoTheDay * 60.0); - return (int)(fractionalMinutesIntoTheDay); + const Real64 currentTimeVal = currentTime(state); + const auto *thisState = static_cast(state); + const Real64 fractionalHoursIntoTheDay = currentTimeVal - static_cast(thisState->dataGlobal->HourOfDay - 1); + const Real64 fractionalMinutesIntoTheDay = std::round(fractionalHoursIntoTheDay * 60.0); + return static_cast(fractionalMinutesIntoTheDay); } int numTimeStepsInHour([[maybe_unused]] EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataGlobal->NumOfTimeStepInHour; } int zoneTimeStepNum([[maybe_unused]] EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataGlobal->TimeStep; } int holidayIndex(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->HolidayIndex; } int sunIsUp(EnergyPlusState state) { // maintain response convention from previous (EMS) implementation - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return (int)thisState->dataEnvrn->SunIsUp; } int isRaining(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return (int)thisState->dataEnvrn->IsRain; } int warmupFlag(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return (int)thisState->dataGlobal->WarmupFlag; } Real64 zoneTimeStep(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataGlobal->TimeStepZone; } Real64 systemTimeStep(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataHVACGlobal->TimeStepSys; } int currentEnvironmentNum(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return thisState->dataEnvrn->CurEnvirNum; } int kindOfSim(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); return static_cast(thisState->dataGlobal->KindOfSim); } @@ -927,11 +919,10 @@ int getConstructionHandle(EnergyPlusState state, const char *constructionName) { int handle = 0; std::string const nameUC = EnergyPlus::Util::makeUPPER(constructionName); - auto *thisState = reinterpret_cast(state); + const auto *thisState = static_cast(state); for (auto const &construct : thisState->dataConstruction->Construct) { handle++; - std::string const thisNameUC = EnergyPlus::Util::makeUPPER(construct.Name); - if (nameUC == thisNameUC) { + if (nameUC == EnergyPlus::Util::makeUPPER(construct.Name)) { return handle; } } @@ -940,393 +931,364 @@ int getConstructionHandle(EnergyPlusState state, const char *constructionName) int actualTime(EnergyPlusState) { - std::string datestring; + const std::string datestring; Array1D_int datevalues(8); ObjexxFCL::date_and_time(datestring, _, _, datevalues); - return double(sum(datevalues({5, 8}))); + return sum(datevalues({5, 8})); } int actualDateTime(EnergyPlusState) { - std::string datestring; - Array1D_int datevalues(8); + const std::string datestring; + const Array1D_int datevalues(8); ObjexxFCL::date_and_time(datestring, _, _, datevalues); - return double(sum(datevalues)); + return sum(datevalues); } int todayWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); - int iHour = hour + 1; + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return (int)thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsRain; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int todayWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); - int iHour = hour + 1; + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return (int)thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsSnow; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } Real64 todayWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); - int iHour = hour + 1; + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutDryBulbTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutDewPointTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); + auto *thisState = static_cast(state); int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutBaroPress; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutRelHum; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).WindSpeed; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).WindDir; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).SkyTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).HorizIRSky; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).BeamSolarRad; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).DifSolarRad; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).Albedo; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 todayWeatherLiquidPrecipitationAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).LiquidPrecip; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } int tomorrowWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsRain; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } int tomorrowWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsSnow; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0; } Real64 tomorrowWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDryBulbTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDryBulbTemp; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDewPointTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDewPointTemp; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutBaroPress; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutBaroPress; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutRelHum; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutRelHum; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindSpeed; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindSpeed; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindDir; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindDir; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).SkyTemp; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).SkyTemp; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).HorizIRSky; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).HorizIRSky; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).BeamSolarRad; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).BeamSolarRad; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).DifSolarRad; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).DifSolarRad; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 tomorrowWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).Albedo; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).Albedo; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } -Real64 tomorrowWeatherLiquidPrecipitationAtTime(EnergyPlusState state, int hour, int timeStepNum) +Real64 tomorrowWeatherLiquidPrecipitationAtTime(EnergyPlusState state, const int hour, const int timeStepNum) { - auto *thisState = reinterpret_cast(state); - int iHour = hour + 1; + auto *thisState = static_cast(state); + const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).LiquidPrecip; - } else { - EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); - thisState->dataPluginManager->apiErrorFlag = true; - return 0.0; + return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).LiquidPrecip; } + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + thisState->dataPluginManager->apiErrorFlag = true; + return 0.0; } Real64 currentSimTime(EnergyPlusState state) { - auto *thisState = reinterpret_cast(state); - Real64 value = (thisState->dataGlobal->DayOfSim - 1) * EnergyPlus::Constant::HoursInDay + currentTime(state); - return value; + const auto *thisState = static_cast(state); + return (thisState->dataGlobal->DayOfSim - 1) * EnergyPlus::Constant::HoursInDay + currentTime(state); } diff --git a/src/EnergyPlus/api/datatransfer.h b/src/EnergyPlus/api/datatransfer.h index 1cae1cf7015..7321ab668b8 100644 --- a/src/EnergyPlus/api/datatransfer.h +++ b/src/EnergyPlus/api/datatransfer.h @@ -135,7 +135,7 @@ ENERGYPLUSLIB_API struct APIDataEntry *getAPIData(EnergyPlusState state, unsigne /// \param[in] data An array (pointer) of API data exchange that points as returned from the getAPIData function /// \param[in] arraySize The size of the API data exchange array, which is known after the call to getAPIData. /// \return Nothing, this simply frees the memory -ENERGYPLUSLIB_API void freeAPIData(struct APIDataEntry *data, unsigned int arraySize); +ENERGYPLUSLIB_API void freeAPIData(const struct APIDataEntry *data, unsigned int arraySize); /// \brief Gets the names of the object instances in the current input file /// \details Although many workflows should be aware of the input file already, there are certain cases where asking EnergyPlus /// to report back the current input file objects has value. The primary application is when a user is still utilizing an IDF based diff --git a/tst/EnergyPlus/api/TestDataTransfer.c b/tst/EnergyPlus/api/TestDataTransfer.c index 77f1f74fe1b..14b4df5a22a 100644 --- a/tst/EnergyPlus/api/TestDataTransfer.c +++ b/tst/EnergyPlus/api/TestDataTransfer.c @@ -70,6 +70,13 @@ void afterZoneTimeStepHandler(EnergyPlusState state) unsigned int arraySize; struct APIDataEntry *data = getAPIData(state, &arraySize); // inspect this to see what's available to exchange + // FILE *fp = fopen("/tmp/data.csv", "w"); + // for (unsigned int a = 0; a < arraySize; a++) { + // const struct APIDataEntry d = *(data + a); + // fprintf(fp, "%s,%s,%s,%s,%s\n", d.what, d.name, d.key, d.type, d.unit); + // } + // fclose(fp); + const char **surfaceNames = getObjectNames(state, "BuildingSurface:Detailed", &arraySize); if (arraySize == 0) { From 0ff97dffd7882809023ad541451d2df95d6e454d Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Fri, 12 Jul 2024 13:49:26 -0500 Subject: [PATCH 105/115] Add brackets to output meters/vars in API, other cleanup --- src/EnergyPlus/DataGlobalConstants.hh | 12 +- src/EnergyPlus/api/datatransfer.cc | 632 +++++++++--------- testfiles/API/user_defined_equipment.py | 1 + testfiles/PythonPluginCustomOutputVariable.py | 1 + 4 files changed, 314 insertions(+), 332 deletions(-) diff --git a/src/EnergyPlus/DataGlobalConstants.hh b/src/EnergyPlus/DataGlobalConstants.hh index 3eb2e85089e..7ddb061d90f 100644 --- a/src/EnergyPlus/DataGlobalConstants.hh +++ b/src/EnergyPlus/DataGlobalConstants.hh @@ -49,7 +49,8 @@ #define DataGlobalConstants_hh_INCLUDED // EnergyPlus Headers -#include +#include +// #include #include namespace EnergyPlus { @@ -482,12 +483,13 @@ namespace Constant { case Units::Invalid: return "invalid"; default: - if (!(0 <= (int)unit && (int)unit < (int)unitNames.size())) { - return "invalid-out-of-range"; + const int iUnit = static_cast(unit); + constexpr int numUnitNames = unitNames.size(); + if (0 <= iUnit && iUnit < numUnitNames) { + return fmt::format("[{}]", unitNames[iUnit]); } - return std::string{unitNames[(unsigned int)unit]}; + return "invalid-out-of-range"; } - return ""; } constexpr std::array unitNamesUC = { diff --git a/src/EnergyPlus/api/datatransfer.cc b/src/EnergyPlus/api/datatransfer.cc index 215fc76e24d..196f1e2b406 100644 --- a/src/EnergyPlus/api/datatransfer.cc +++ b/src/EnergyPlus/api/datatransfer.cc @@ -60,14 +60,15 @@ #include #include #include -// #include #include #include #include #include -APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) { - struct LocalAPIDataEntry { +APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) +{ + struct LocalAPIDataEntry + { std::string what; std::string name; std::string type; @@ -75,42 +76,38 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) { std::string unit; LocalAPIDataEntry(std::string _what, std::string _name, std::string _type, std::string _key, std::string _unit) - : what(std::move(_what)), name(std::move(_name)), type(std::move(_type)), key(std::move(_key)), - unit(std::move(_unit)) { + : what(std::move(_what)), name(std::move(_name)), type(std::move(_type)), key(std::move(_key)), unit(std::move(_unit)) + { } }; std::vector localDataEntries; auto *thisState = static_cast(state); - for (auto const &availActuator: thisState->dataRuntimeLang->EMSActuatorAvailable) { - if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator. - ControlTypeName.empty()) { + for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { + if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { break; } localDataEntries.emplace_back( - "Actuator", availActuator.ComponentTypeName, availActuator.ControlTypeName, availActuator.UniqueIDName, - availActuator.Units); + "Actuator", availActuator.ComponentTypeName, availActuator.ControlTypeName, availActuator.UniqueIDName, availActuator.Units); } - for (auto const &availVariable: thisState->dataRuntimeLang->EMSInternalVarsAvailable) { + for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { if (availVariable.DataTypeName.empty() && availVariable.UniqueIDName.empty()) { break; } - localDataEntries.emplace_back("InternalVariable", availVariable.DataTypeName, "", availVariable.UniqueIDName, - availVariable.Units); + localDataEntries.emplace_back("InternalVariable", availVariable.DataTypeName, "", availVariable.UniqueIDName, availVariable.Units); } - for (auto const &gVarName: thisState->dataPluginManager->globalVariableNames) { + for (auto const &gVarName : thisState->dataPluginManager->globalVariableNames) { localDataEntries.emplace_back("PluginGlobalVariable", "", "", gVarName, ""); } - for (auto const &trend: thisState->dataPluginManager->trends) { + for (auto const &trend : thisState->dataPluginManager->trends) { localDataEntries.emplace_back("PluginTrendVariable,", "", "", trend.name, ""); } - for (auto const *meter: thisState->dataOutputProcessor->meters) { + for (auto const *meter : thisState->dataOutputProcessor->meters) { if (meter->Name.empty()) { break; } - localDataEntries.emplace_back("OutputMeter", "", "", meter->Name, - EnergyPlus::Constant::unitToString(meter->units)); + localDataEntries.emplace_back("OutputMeter", "", "", meter->Name, EnergyPlus::Constant::unitToString(meter->units)); } - for (auto const *variable: thisState->dataOutputProcessor->outVars) { + for (auto const *variable : thisState->dataOutputProcessor->outVars) { if (variable->varType != EnergyPlus::OutputProcessor::VariableType::Real) continue; if (variable->name.empty() && variable->keyUC.empty()) { break; @@ -140,7 +137,8 @@ APIDataEntry *getAPIData(EnergyPlusState state, unsigned int *resultingSize) { return data; } -void freeAPIData(const APIDataEntry *data, const unsigned int arraySize) { +void freeAPIData(const APIDataEntry *data, const unsigned int arraySize) +{ for (unsigned int i = 0; i < arraySize; i++) { delete[] data[i].what; delete[] data[i].name; @@ -151,12 +149,12 @@ void freeAPIData(const APIDataEntry *data, const unsigned int arraySize) { delete[] data; } -char *listAllAPIDataCSV(EnergyPlusState state) { +char *listAllAPIDataCSV(EnergyPlusState state) +{ auto *thisState = static_cast(state); std::string output = "**ACTUATORS**\n"; - for (auto const &availActuator: thisState->dataRuntimeLang->EMSActuatorAvailable) { - if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator. - ControlTypeName.empty()) { + for (auto const &availActuator : thisState->dataRuntimeLang->EMSActuatorAvailable) { + if (availActuator.ComponentTypeName.empty() && availActuator.UniqueIDName.empty() && availActuator.ControlTypeName.empty()) { break; } output.append("Actuator,"); @@ -166,7 +164,7 @@ char *listAllAPIDataCSV(EnergyPlusState state) { output.append(availActuator.Units).append("\n"); } output.append("**INTERNAL_VARIABLES**\n"); - for (auto const &availVariable: thisState->dataRuntimeLang->EMSInternalVarsAvailable) { + for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { if (availVariable.DataTypeName.empty() && availVariable.UniqueIDName.empty()) { break; } @@ -176,17 +174,17 @@ char *listAllAPIDataCSV(EnergyPlusState state) { output.append(availVariable.Units).append("\n"); } output.append("**PLUGIN_GLOBAL_VARIABLES**\n"); - for (auto const &gVarName: thisState->dataPluginManager->globalVariableNames) { + for (auto const &gVarName : thisState->dataPluginManager->globalVariableNames) { output.append("PluginGlobalVariable,"); output.append(gVarName).append("\n"); } output.append("**TRENDS**\n"); - for (auto const &trend: thisState->dataPluginManager->trends) { + for (auto const &trend : thisState->dataPluginManager->trends) { output.append("PluginTrendVariable,"); output.append(trend.name).append("\n"); } output.append("**METERS**\n"); - for (auto const *meter: thisState->dataOutputProcessor->meters) { + for (auto const *meter : thisState->dataOutputProcessor->meters) { if (meter->Name.empty()) { break; } @@ -195,7 +193,7 @@ char *listAllAPIDataCSV(EnergyPlusState state) { output.append(EnergyPlus::Constant::unitToString(meter->units)).append("\n"); } output.append("**VARIABLES**\n"); - for (auto const *variable: thisState->dataOutputProcessor->outVars) { + for (auto const *variable : thisState->dataOutputProcessor->outVars) { if (variable->varType != EnergyPlus::OutputProcessor::VariableType::Real) continue; if (variable->name.empty() && variable->keyUC.empty()) { break; @@ -204,10 +202,9 @@ char *listAllAPIDataCSV(EnergyPlusState state) { output.append(variable->name).append(","); output.append(variable->keyUC).append(","); output - .append(variable->units == EnergyPlus::Constant::Units::customEMS - ? variable->unitNameCustomEMS - : EnergyPlus::Constant::unitToString(variable->units)) - .append("\n"); + .append(variable->units == EnergyPlus::Constant::Units::customEMS ? variable->unitNameCustomEMS + : EnergyPlus::Constant::unitToString(variable->units)) + .append("\n"); } // note that we cannot just return a c_str to the local string, as the string will be destructed upon leaving // this function, and undefined behavior will occur. @@ -218,7 +215,8 @@ char *listAllAPIDataCSV(EnergyPlusState state) { return p; } -int apiDataFullyReady(EnergyPlusState state) { +int apiDataFullyReady(EnergyPlusState state) +{ const auto *thisState = static_cast(state); if (thisState->dataPluginManager->fullyReady) { return 1; @@ -226,7 +224,8 @@ int apiDataFullyReady(EnergyPlusState state) { return 0; } -int apiErrorFlag(EnergyPlusState state) { +int apiErrorFlag(EnergyPlusState state) +{ const auto *thisState = static_cast(state); if (thisState->dataPluginManager->apiErrorFlag) { return 1; @@ -234,12 +233,14 @@ int apiErrorFlag(EnergyPlusState state) { return 0; } -void resetErrorFlag(EnergyPlusState state) { +void resetErrorFlag(EnergyPlusState state) +{ const auto *thisState = static_cast(state); thisState->dataPluginManager->apiErrorFlag = false; } -char **getObjectNames(EnergyPlusState state, const char *objectType, unsigned int *resultingSize) { +char **getObjectNames(EnergyPlusState state, const char *objectType, unsigned int *resultingSize) +{ const auto *thisState = static_cast(state); auto &epjson = thisState->dataInputProcessing->inputProcessor->epJSON; const auto instances = epjson.find(objectType); @@ -260,21 +261,24 @@ char **getObjectNames(EnergyPlusState state, const char *objectType, unsigned in return data; } -void freeObjectNames(char **objectNames, unsigned int arraySize) { +void freeObjectNames(char **objectNames, unsigned int arraySize) +{ // as of right now we don't actually need to free the underlying strings, they exist in the epJSON instance, so just delete our array of pointers - (void) arraySize; + (void)arraySize; // no op to avoid compiler warning that this variable is unused, in the future, this may be needed so keeping it in the API now delete[] objectNames; } -int getNumNodesInCondFDSurfaceLayer(EnergyPlusState state, const char *surfName, const char *matName) { +int getNumNodesInCondFDSurfaceLayer(EnergyPlusState state, const char *surfName, const char *matName) +{ auto *thisState = static_cast(state); std::string UCsurfName = EnergyPlus::Util::makeUPPER(surfName); std::string UCmatName = EnergyPlus::Util::makeUPPER(matName); return EnergyPlus::HeatBalFiniteDiffManager::numNodesInMaterialLayer(*thisState, UCsurfName, UCmatName); } -void requestVariable(EnergyPlusState state, const char *type, const char *key) { +void requestVariable(EnergyPlusState state, const char *type, const char *key) +{ // allow specifying a request for an output variable, so that E+ does not have to keep all of them in memory // should be called before energyplus is run! // note that the variable request array is cleared during clear_state, so if you run multiple E+ runs, these must be requested again each time. @@ -285,7 +289,8 @@ void requestVariable(EnergyPlusState state, const char *type, const char *key) { thisState->dataOutputProcessor->apiVarRequests.push_back(request); } -int getVariableHandle(EnergyPlusState state, const char *type, const char *key) { +int getVariableHandle(EnergyPlusState state, const char *type, const char *key) +{ // Variables are accessed through a single integer ID, but there are multiple internal types: real and integer. // I am going to make the integer handle span all both types, by carefully defining the handle. // basically, the handles are contiguous, with: @@ -307,7 +312,8 @@ int getVariableHandle(EnergyPlusState state, const char *type, const char *key) return -1; // return -1 if it wasn't found } -Real64 getVariableValue(EnergyPlusState state, const int handle) { +Real64 getVariableValue(EnergyPlusState state, const int handle) +{ // this function works in conjunction with the plan set up in getVariableHandle // basically, the handles are contiguous, with: // - index 1 being the first real variable handle @@ -322,42 +328,37 @@ Real64 getVariableValue(EnergyPlusState state, const int handle) { return *(dynamic_cast(thisOutputVar))->Which; } if (thisOutputVar->varType == EnergyPlus::OutputProcessor::VariableType::Integer) { - return (Real64) *(dynamic_cast(thisOutputVar))->Which; + return (Real64) * (dynamic_cast(thisOutputVar))->Which; } if (thisState->dataGlobal->errorCallback) { - std::cout - << "ERROR: Variable at handle has type other than Real or Integer, returning zero but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Variable at handle has type other than Real or Integer, returning zero but caller should take note and likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: Error in getVariableValue; received handle: {}", handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Error in getVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Variable handle out of range in getVariableValue, returning zero but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Variable handle out of range in getVariableValue, returning zero but caller should take note and likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: Index error in getVariableValue; received handle: {}", handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int getMeterHandle(EnergyPlusState state, const char *meterName) { +int getMeterHandle(EnergyPlusState state, const char *meterName) +{ auto *thisState = static_cast(state); std::string const meterNameUC = EnergyPlus::Util::makeUPPER(meterName); const int i = EnergyPlus::GetMeterIndex(*thisState, meterNameUC); @@ -368,30 +369,27 @@ int getMeterHandle(EnergyPlusState state, const char *meterName) { return i; } -Real64 getMeterValue(EnergyPlusState state, int handle) { +Real64 getMeterValue(EnergyPlusState state, int handle) +{ auto *thisState = static_cast(state); if (handle >= 0 && handle < thisState->dataOutputProcessor->meters.size()) { return EnergyPlus::GetCurrentMeterValue(*thisState, handle); } if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Meter handle out of range in getMeterValue, returning zero but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Meter handle out of range in getMeterValue, returning zero but caller should take note and likely abort." << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return zero - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: Index error in getMeterValue; received handle: {}", handle)); - EnergyPlus::ShowContinueError( - *thisState, - "The getMeterValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: Index error in getMeterValue; received handle: {}", handle)); + EnergyPlus::ShowContinueError(*thisState, + "The getMeterValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int getActuatorHandle(EnergyPlusState state, const char *componentType, const char *controlType, - const char *uniqueKey) { +int getActuatorHandle(EnergyPlusState state, const char *componentType, const char *controlType, const char *uniqueKey) +{ int handle = 0; std::string const typeUC = EnergyPlus::Util::makeUPPER(componentType); std::string const keyUC = EnergyPlus::Util::makeUPPER(uniqueKey); @@ -407,22 +405,18 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch if (availActuator.handleCount > 0) { // If the handle is already used by an IDF EnergyManagementSystem:Actuator, we should warn the user bool foundActuator = false; - for (auto const &usedActuator: thisState->dataRuntimeLang->EMSActuatorUsed) { + for (auto const &usedActuator : thisState->dataRuntimeLang->EMSActuatorUsed) { if (usedActuator.ActuatorVariableNum == handle) { EnergyPlus::ShowWarningError( *thisState, - "Data Exchange API: An EnergyManagementSystem:Actuator seems to be already defined in the EnergyPlus File and named '" - + - usedActuator.Name + "'."); + "Data Exchange API: An EnergyManagementSystem:Actuator seems to be already defined in the EnergyPlus File and named '" + + usedActuator.Name + "'."); EnergyPlus::ShowContinueError( - *thisState, fmt::format( - "Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", typeUC, controlUC, - keyUC)); + *thisState, fmt::format("Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", typeUC, controlUC, keyUC)); EnergyPlus::ShowContinueError(*thisState, - fmt::format( - "The getActuatorHandle function will still return the handle (= {}) but caller " - "should take note that there is a risk of overwritting.", - handle)); + fmt::format("The getActuatorHandle function will still return the handle (= {}) but caller " + "should take note that there is a risk of overwritting.", + handle)); foundActuator = true; break; } @@ -431,13 +425,11 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch EnergyPlus::ShowWarningError(*thisState, "Data Exchange API: You seem to already have tried to get an Actuator Handle on this one."); EnergyPlus::ShowContinueError( - *thisState, fmt::format("Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", - typeUC, controlUC, keyUC)); + *thisState, fmt::format("Occurred for componentType='{}', controlType='{}', uniqueKey='{}'.", typeUC, controlUC, keyUC)); EnergyPlus::ShowContinueError(*thisState, - fmt::format( - "The getActuatorHandle function will still return the handle (= {}) but caller should " - "take note that there is a risk of overwritting.", - handle)); + fmt::format("The getActuatorHandle function will still return the handle (= {}) but caller should " + "take note that there is a risk of overwritting.", + handle)); } } ++availActuator.handleCount; @@ -448,7 +440,8 @@ int getActuatorHandle(EnergyPlusState state, const char *componentType, const ch return -1; } -void resetActuator(EnergyPlusState state, int handle) { +void resetActuator(EnergyPlusState state, int handle) +{ // resets the actuator so that E+ will use the internally calculated value again auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { @@ -456,15 +449,11 @@ void resetActuator(EnergyPlusState state, int handle) { *theActuator.Actuated = false; } else { if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Actuator handle out of range in resetActuator, returning but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Actuator handle out of range in resetActuator, returning but caller should take note and likely abort." << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: index error in resetActuator; received handle: {}", - handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: index error in resetActuator; received handle: {}", handle)); EnergyPlus::ShowContinueError(*thisState, "The resetActuator function will return to allow the plugin to finish, then EnergyPlus will abort"); } @@ -472,7 +461,8 @@ void resetActuator(EnergyPlusState state, int handle) { } } -void setActuatorValue(EnergyPlusState state, const int handle, const Real64 value) { +void setActuatorValue(EnergyPlusState state, const int handle, const Real64 value) +{ auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); @@ -488,15 +478,12 @@ void setActuatorValue(EnergyPlusState state, const int handle, const Real64 valu *theActuator.Actuated = true; } else { if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Actuator handle out of range in setActuatorValue, returning but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Actuator handle out of range in setActuatorValue, returning but caller should take note and likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: index error in setActuatorValue; received handle: {}", - handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: index error in setActuatorValue; received handle: {}", handle)); EnergyPlus::ShowContinueError(*thisState, "The setActuatorValue function will return to allow the plugin to finish, then EnergyPlus will abort"); } @@ -504,7 +491,8 @@ void setActuatorValue(EnergyPlusState state, const int handle, const Real64 valu } } -Real64 getActuatorValue(EnergyPlusState state, const int handle) { +Real64 getActuatorValue(EnergyPlusState state, const int handle) +{ auto *thisState = static_cast(state); if (handle >= 1 && handle <= thisState->dataRuntimeLang->numEMSActuatorsAvailable) { const auto &theActuator(thisState->dataRuntimeLang->EMSActuatorAvailable(handle)); @@ -521,28 +509,26 @@ Real64 getActuatorValue(EnergyPlusState state, const int handle) { return 0; } if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Actuator handle out of range in getActuatorValue, returning zero but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Actuator handle out of range in getActuatorValue, returning zero but caller should take note and likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return 0 - EnergyPlus::ShowSevereError( - *thisState, fmt::format("Data Exchange API: index error in getActuatorValue; received handle: {}", handle)); + EnergyPlus::ShowSevereError(*thisState, fmt::format("Data Exchange API: index error in getActuatorValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getActuatorValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getActuatorValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int getInternalVariableHandle(EnergyPlusState state, const char *type, const char *key) { +int getInternalVariableHandle(EnergyPlusState state, const char *type, const char *key) +{ int handle = 0; std::string const typeUC = EnergyPlus::Util::makeUPPER(type); std::string const keyUC = EnergyPlus::Util::makeUPPER(key); const auto *thisState = static_cast(state); - for (auto const &availVariable: thisState->dataRuntimeLang->EMSInternalVarsAvailable) { + for (auto const &availVariable : thisState->dataRuntimeLang->EMSInternalVarsAvailable) { // TODO: this should stop at numEMSInternalVarsAvailable handle++; std::string const variableTypeUC = EnergyPlus::Util::makeUPPER(availVariable.DataTypeName); @@ -554,138 +540,124 @@ int getInternalVariableHandle(EnergyPlusState state, const char *type, const cha return -1; } -Real64 getInternalVariableValue(EnergyPlusState state, int handle) { +Real64 getInternalVariableValue(EnergyPlusState state, int handle) +{ auto *thisState = static_cast(state); - if (handle >= 1 && handle <= (int) thisState->dataRuntimeLang->numEMSInternalVarsAvailable) { + if (handle >= 1 && handle <= (int)thisState->dataRuntimeLang->numEMSInternalVarsAvailable) { auto const &thisVar = thisState->dataRuntimeLang->EMSInternalVarsAvailable(handle); if (thisVar.PntrVarTypeUsed == EnergyPlus::DataRuntimeLanguage::PtrDataType::Real) { return *thisVar.RealValue; } if (thisVar.PntrVarTypeUsed == EnergyPlus::DataRuntimeLanguage::PtrDataType::Integer) { - return (Real64) (*thisVar.IntValue); + return (Real64)(*thisVar.IntValue); } // Doesn't look like this struct actually has a logical member type, so uh, throw here? - std::cout << - "ERROR: Invalid internal variable type here, developer issue., returning zero but caller should take note and likely abort." - << std::endl; + std::cout << "ERROR: Invalid internal variable type here, developer issue., returning zero but caller should take note and likely abort." + << std::endl; thisState->dataPluginManager->apiErrorFlag = true; return 0; } if (thisState->dataGlobal->errorCallback) { - std::cout << - "ERROR: Internal variable handle out of range in getInternalVariableValue, returning zero but caller should take note and " - "likely abort." - << std::endl; + std::cout << "ERROR: Internal variable handle out of range in getInternalVariableValue, returning zero but caller should take note and " + "likely abort." + << std::endl; } else { // must be running from python plugin, need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return 0 EnergyPlus::ShowSevereError(*thisState, - fmt::format( - "Data Exchange API: index error in getInternalVariableValue; received handle: {}", - handle)); + fmt::format("Data Exchange API: index error in getInternalVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getInternalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getInternalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); } thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int getPluginGlobalVariableHandle(EnergyPlusState state, const char *name) { +int getPluginGlobalVariableHandle(EnergyPlusState state, const char *name) +{ auto *thisState = static_cast(state); return thisState->dataPluginManager->pluginManager->getGlobalVariableHandle(*thisState, name); } -Real64 getPluginGlobalVariableValue(EnergyPlusState state, int handle) { +Real64 getPluginGlobalVariableValue(EnergyPlusState state, int handle) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxGlobalVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return 0 EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginGlobalVariableValue; received handle: {}", - handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginGlobalVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginGlobalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginGlobalVariableValue function will return 0 for now to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return thisState->dataPluginManager->pluginManager->getGlobalVariableValue(*thisState, handle); } -void setPluginGlobalVariableValue(EnergyPlusState state, int handle, Real64 value) { +void setPluginGlobalVariableValue(EnergyPlusState state, int handle, Real64 value) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxGlobalVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in setPluginGlobalVariableValue; received handle: {}", - handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in setPluginGlobalVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginGlobalVariableValue function will return to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginGlobalVariableValue function will return to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; } thisState->dataPluginManager->pluginManager->setGlobalVariableValue(*thisState, handle, value); } -int getPluginTrendVariableHandle(EnergyPlusState state, const char *name) { +int getPluginTrendVariableHandle(EnergyPlusState state, const char *name) +{ auto *thisState = static_cast(state); return EnergyPlus::PluginManagement::PluginManager::getTrendVariableHandle(*thisState, name); } -Real64 getPluginTrendVariableValue(EnergyPlusState state, int handle, int timeIndex) { +Real64 getPluginTrendVariableValue(EnergyPlusState state, int handle, int timeIndex) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableValue; received handle: {}", - handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableValue; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableValue function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableValue function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (timeIndex < 1 || timeIndex > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (timeIndex < 1 || timeIndex > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( *thisState, - fmt::format( - "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableValue; received value: {}", - timeIndex)); + fmt::format("Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableValue; received value: {}", + timeIndex)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableValue function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableValue function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableValue(*thisState, handle, timeIndex); } -Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int count) { +Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int count) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableAverage; received handle: {}", - handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableAverage; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableAverage function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableAverage function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -694,127 +666,111 @@ Real64 getPluginTrendVariableAverage(EnergyPlusState state, int handle, int coun "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableAverage; received value: {}", count)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableAverage function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableAverage function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableAverage(*thisState, handle, count); } -Real64 getPluginTrendVariableMin(EnergyPlusState state, int handle, int count) { +Real64 getPluginTrendVariableMin(EnergyPlusState state, int handle, int count) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableMin; received handle: {}", handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableMin; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableMin function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableMin function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( *thisState, - fmt::format( - "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableMin; received value: {}", - count)); + fmt::format("Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableMin; received value: {}", + count)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableMin function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableMin function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableMin(*thisState, handle, count); } -Real64 getPluginTrendVariableMax(EnergyPlusState state, int handle, int count) { +Real64 getPluginTrendVariableMax(EnergyPlusState state, int handle, int count) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableMax; received handle: {}", handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableMax; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableMax function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableMax function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( *thisState, - fmt::format( - "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableMax; received value: {}", - count)); + fmt::format("Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableMax; received value: {}", + count)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableMax function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableMax function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableMax(*thisState, handle, count); } -Real64 getPluginTrendVariableSum(EnergyPlusState state, int handle, int count) { +Real64 getPluginTrendVariableSum(EnergyPlusState state, int handle, int count) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableSum; received handle: {}", handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableSum; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableSum function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableSum function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( *thisState, - fmt::format( - "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableSum; received value: {}", - count)); + fmt::format("Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableSum; received value: {}", + count)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableSum function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableSum function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableSum(*thisState, handle, count); } -Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int count) { +Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int count) +{ auto *thisState = static_cast(state); if (handle < 0 || handle > thisState->dataPluginManager->pluginManager->maxTrendVariableIndex) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( - *thisState, fmt::format( - "Data Exchange API: Problem -- index error in getPluginTrendVariableDirection; received handle: {}", - handle)); + *thisState, fmt::format("Data Exchange API: Problem -- index error in getPluginTrendVariableDirection; received handle: {}", handle)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableDirection function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableDirection function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } - if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize( - *thisState, handle)) { + if (count < 2 || count > EnergyPlus::PluginManagement::PluginManager::getTrendVariableHistorySize(*thisState, handle)) { // need to fatal out once the plugin is done // throw an error, set the fatal flag, and then return EnergyPlus::ShowSevereError( @@ -823,68 +779,76 @@ Real64 getPluginTrendVariableDirection(EnergyPlusState state, int handle, int co "Data Exchange API: Problem -- trend history count argument out of range in getPluginTrendVariableDirection; received value: {}", count)); EnergyPlus::ShowContinueError( - *thisState, - "The getPluginTrendVariableDirection function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); + *thisState, "The getPluginTrendVariableDirection function will return 0 to allow the plugin to finish, then EnergyPlus will abort"); thisState->dataPluginManager->apiErrorFlag = true; return 0; } return EnergyPlus::PluginManagement::PluginManager::getTrendVariableDirection(*thisState, handle, count); } -int year(EnergyPlusState state) { +int year(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->Year; } -int calendarYear(EnergyPlusState state) { +int calendarYear(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataGlobal->CalendarYear; } -int month(EnergyPlusState state) { +int month(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->Month; } -int dayOfMonth(EnergyPlusState state) { +int dayOfMonth(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfMonth; } -int dayOfWeek(EnergyPlusState state) { +int dayOfWeek(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfWeek; } -int dayOfYear(EnergyPlusState state) { +int dayOfYear(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->DayOfYear; } -int daylightSavingsTimeIndicator(EnergyPlusState state) { +int daylightSavingsTimeIndicator(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->DSTIndicator; } -int hour(EnergyPlusState state) { +int hour(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataGlobal->HourOfDay - 1; // no, just stay on 0..23+ DSTadjust ! offset by 1 and daylight savings time } -Real64 currentTime(EnergyPlusState state) { +Real64 currentTime(EnergyPlusState state) +{ const auto *thisState = static_cast(state); if (thisState->dataHVACGlobal->TimeStepSys < thisState->dataGlobal->TimeStepZone) { // CurrentTime is for end of zone timestep, need to move back to beginning of current zone timestep, then add on system time elapsed already // plus current system timestep - return thisState->dataGlobal->CurrentTime - thisState->dataGlobal->TimeStepZone + thisState->dataHVACGlobal-> - SysTimeElapsed + + return thisState->dataGlobal->CurrentTime - thisState->dataGlobal->TimeStepZone + thisState->dataHVACGlobal->SysTimeElapsed + thisState->dataHVACGlobal->TimeStepSys; } return thisState->dataGlobal->CurrentTime; } -int minutes(EnergyPlusState state) { +int minutes(EnergyPlusState state) +{ // the -1 is to push us to the right minute, but this should be handled cautiously because if we are inside the HVAC iteration loop, // currentTime() returns a floating point fractional hour, so truncation could put this a few seconds from the expected minute. const Real64 currentTimeVal = currentTime(state); @@ -894,62 +858,73 @@ int minutes(EnergyPlusState state) { return static_cast(fractionalMinutesIntoTheDay); } -int numTimeStepsInHour([[maybe_unused]] EnergyPlusState state) { +int numTimeStepsInHour([[maybe_unused]] EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataGlobal->NumOfTimeStepInHour; } -int zoneTimeStepNum([[maybe_unused]] EnergyPlusState state) { +int zoneTimeStepNum([[maybe_unused]] EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataGlobal->TimeStep; } -int holidayIndex(EnergyPlusState state) { +int holidayIndex(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->HolidayIndex; } -int sunIsUp(EnergyPlusState state) { +int sunIsUp(EnergyPlusState state) +{ // maintain response convention from previous (EMS) implementation const auto *thisState = static_cast(state); - return (int) thisState->dataEnvrn->SunIsUp; + return (int)thisState->dataEnvrn->SunIsUp; } -int isRaining(EnergyPlusState state) { +int isRaining(EnergyPlusState state) +{ const auto *thisState = static_cast(state); - return (int) thisState->dataEnvrn->IsRain; + return (int)thisState->dataEnvrn->IsRain; } -int warmupFlag(EnergyPlusState state) { +int warmupFlag(EnergyPlusState state) +{ const auto *thisState = static_cast(state); - return (int) thisState->dataGlobal->WarmupFlag; + return (int)thisState->dataGlobal->WarmupFlag; } -Real64 zoneTimeStep(EnergyPlusState state) { +Real64 zoneTimeStep(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataGlobal->TimeStepZone; } -Real64 systemTimeStep(EnergyPlusState state) { +Real64 systemTimeStep(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataHVACGlobal->TimeStepSys; } -int currentEnvironmentNum(EnergyPlusState state) { +int currentEnvironmentNum(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return thisState->dataEnvrn->CurEnvirNum; } -int kindOfSim(EnergyPlusState state) { +int kindOfSim(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return static_cast(thisState->dataGlobal->KindOfSim); } -int getConstructionHandle(EnergyPlusState state, const char *constructionName) { +int getConstructionHandle(EnergyPlusState state, const char *constructionName) +{ int handle = 0; std::string const nameUC = EnergyPlus::Util::makeUPPER(constructionName); const auto *thisState = static_cast(state); - for (auto const &construct: thisState->dataConstruction->Construct) { + for (auto const &construct : thisState->dataConstruction->Construct) { handle++; if (nameUC == EnergyPlus::Util::makeUPPER(construct.Name)) { return handle; @@ -958,49 +933,52 @@ int getConstructionHandle(EnergyPlusState state, const char *constructionName) { return -1; // return -1 if it wasn't found } -int actualTime(EnergyPlusState) { +int actualTime(EnergyPlusState) +{ const std::string datestring; Array1D_int datevalues(8); ObjexxFCL::date_and_time(datestring, _, _, datevalues); return sum(datevalues({5, 8})); } -int actualDateTime(EnergyPlusState) { +int actualDateTime(EnergyPlusState) +{ const std::string datestring; const Array1D_int datevalues(8); ObjexxFCL::date_and_time(datestring, _, _, datevalues); return sum(datevalues); } -int todayWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) { +int todayWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int) thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsRain; + return (int)thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsRain; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int todayWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) { +int todayWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int) thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsSnow; + return (int)thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).IsSnow; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0; } -Real64 todayWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; @@ -1008,338 +986,338 @@ Real64 todayWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeSte (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutDryBulbTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutDewPointTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutBaroPress; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).OutRelHum; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).WindSpeed; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).WindDir; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).SkyTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).HorizIRSky; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).BeamSolarRad; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).DifSolarRad; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).Albedo; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 todayWeatherLiquidPrecipitationAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 todayWeatherLiquidPrecipitationAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsToday(timeStepNum, iHour).LiquidPrecip; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -int tomorrowWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) { +int tomorrowWeatherIsRainAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int) thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsRain; + return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsRain; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0; } -int tomorrowWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) { +int tomorrowWeatherIsSnowAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { - return (int) thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsSnow; + return (int)thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).IsSnow; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0; } -Real64 tomorrowWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherOutDryBulbAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDryBulbTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherOutDewPointAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutDewPointTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherOutBarometricPressureAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutBaroPress; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherOutRelativeHumidityAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).OutRelHum; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherWindSpeedAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindSpeed; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherWindDirectionAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).WindDir; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherSkyTemperatureAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).SkyTemp; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherHorizontalIRSkyAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).HorizIRSky; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherBeamSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).BeamSolarRad; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherDiffuseSolarRadiationAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).DifSolarRad; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) { +Real64 tomorrowWeatherAlbedoAtTime(EnergyPlusState state, int hour, int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).Albedo; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 tomorrowWeatherLiquidPrecipitationAtTime(EnergyPlusState state, const int hour, const int timeStepNum) { +Real64 tomorrowWeatherLiquidPrecipitationAtTime(EnergyPlusState state, const int hour, const int timeStepNum) +{ auto *thisState = static_cast(state); const int iHour = hour + 1; if ((iHour > 0) && (iHour <= EnergyPlus::Constant::HoursInDay) && (timeStepNum > 0) && (timeStepNum <= thisState->dataGlobal->NumOfTimeStepInHour)) { return thisState->dataWeather->wvarsHrTsTomorrow(timeStepNum, iHour).LiquidPrecip; } - EnergyPlus::ShowSevereError( - *thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); + EnergyPlus::ShowSevereError(*thisState, "Invalid return from weather lookup, check hour and time step argument values are in range."); thisState->dataPluginManager->apiErrorFlag = true; return 0.0; } -Real64 currentSimTime(EnergyPlusState state) { +Real64 currentSimTime(EnergyPlusState state) +{ const auto *thisState = static_cast(state); return (thisState->dataGlobal->DayOfSim - 1) * EnergyPlus::Constant::HoursInDay + currentTime(state); } diff --git a/testfiles/API/user_defined_equipment.py b/testfiles/API/user_defined_equipment.py index 7236a31b37b..6fbf723a185 100644 --- a/testfiles/API/user_defined_equipment.py +++ b/testfiles/API/user_defined_equipment.py @@ -462,6 +462,7 @@ def operate(self, state): self.get_handles(state) if not self.handles_gotten_properly(state): return 1 + # x = api_.exchange.get_api_data(state) # use this to inspect api data self.initialize(state) self.simulate(state) self.report(state) diff --git a/testfiles/PythonPluginCustomOutputVariable.py b/testfiles/PythonPluginCustomOutputVariable.py index 5aecbae487b..9548d319f8d 100644 --- a/testfiles/PythonPluginCustomOutputVariable.py +++ b/testfiles/PythonPluginCustomOutputVariable.py @@ -75,6 +75,7 @@ def on_end_of_zone_timestep_before_zone_reporting(self, state) -> int: self.api.exchange.get_variable_handle(state, "Zone Mean Air Temperature", zone_name) ) self.data["avg_temp_variable"] = self.api.exchange.get_global_handle(state, "AverageBuildingTemp") + # x = self.api.exchange.get_api_data(state) # use this to inspect API data self.do_setup = False zone_temps = list() for t_handle in self.data["zone_temps"]: From f8641777dc11306e10f7a86fb94efc9876a56ba3 Mon Sep 17 00:00:00 2001 From: amirroth Date: Mon, 15 Jul 2024 13:10:21 -0400 Subject: [PATCH 106/115] Fluid properties API with one usage example (VRF) --- src/EnergyPlus/AirLoopHVACDOAS.cc | 6 +- .../CoolingWaterDesAirOutletTempSizing.cc | 4 +- .../Autosizing/CoolingWaterflowSizing.cc | 8 +- .../HeatingWaterDesCoilLoadUsedForUASizing.cc | 12 +- .../Autosizing/HeatingWaterflowSizing.cc | 8 +- .../Autosizing/WaterHeatingCapacitySizing.cc | 8 +- src/EnergyPlus/BaseboardRadiator.cc | 4 +- src/EnergyPlus/BoilerSteam.cc | 44 +- src/EnergyPlus/Boilers.cc | 8 +- src/EnergyPlus/CTElectricGenerator.cc | 4 +- src/EnergyPlus/ChilledCeilingPanelSimple.cc | 14 +- src/EnergyPlus/ChillerAbsorption.cc | 52 +- src/EnergyPlus/ChillerElectricASHRAE205.cc | 26 +- src/EnergyPlus/ChillerElectricEIR.cc | 24 +- src/EnergyPlus/ChillerExhaustAbsorption.cc | 20 +- src/EnergyPlus/ChillerGasAbsorption.cc | 20 +- src/EnergyPlus/ChillerIndirectAbsorption.cc | 54 +- src/EnergyPlus/ChillerReformulatedEIR.cc | 26 +- src/EnergyPlus/CondenserLoopTowers.cc | 88 +- src/EnergyPlus/Data/EnergyPlusData.cc | 6 +- src/EnergyPlus/Data/EnergyPlusData.hh | 2 +- src/EnergyPlus/DaylightingDevices.cc | 2 +- src/EnergyPlus/DesiccantDehumidifiers.cc | 12 +- src/EnergyPlus/EvaporativeFluidCoolers.cc | 42 +- src/EnergyPlus/FanCoilUnits.cc | 12 +- src/EnergyPlus/FluidCoolers.cc | 32 +- src/EnergyPlus/FluidProperties.cc | 3323 +++++++++-------- src/EnergyPlus/FluidProperties.hh | 424 ++- src/EnergyPlus/FuelCellElectricGenerator.cc | 4 +- src/EnergyPlus/Furnaces.cc | 26 +- src/EnergyPlus/GroundHeatExchangers.cc | 30 +- src/EnergyPlus/HVACControllers.cc | 2 +- src/EnergyPlus/HVACCooledBeam.cc | 10 +- src/EnergyPlus/HVACFourPipeBeam.cc | 20 +- src/EnergyPlus/HVACInterfaceManager.cc | 6 +- src/EnergyPlus/HVACMultiSpeedHeatPump.cc | 24 +- src/EnergyPlus/HVACSingleDuctInduc.cc | 12 +- src/EnergyPlus/HVACSizingSimulationManager.cc | 4 +- src/EnergyPlus/HVACUnitaryBypassVAV.cc | 10 +- src/EnergyPlus/HVACVariableRefrigerantFlow.cc | 449 +-- src/EnergyPlus/HVACVariableRefrigerantFlow.hh | 4 +- src/EnergyPlus/HWBaseboardRadiator.cc | 16 +- src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc | 26 +- src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc | 26 +- src/EnergyPlus/HeatPumpWaterToWaterSimple.cc | 48 +- src/EnergyPlus/Humidifiers.cc | 20 +- src/EnergyPlus/ICEngineElectricGenerator.cc | 4 +- src/EnergyPlus/IceThermalStorage.cc | 6 +- src/EnergyPlus/LowTempRadiantSystem.cc | 23 +- src/EnergyPlus/MicroCHPElectricGenerator.cc | 8 +- .../MicroturbineElectricGenerator.cc | 6 +- src/EnergyPlus/NodeInputManager.cc | 12 +- src/EnergyPlus/OutdoorAirUnit.cc | 7 +- src/EnergyPlus/OutsideEnergySources.cc | 22 +- src/EnergyPlus/PackagedThermalStorageCoil.cc | 37 +- .../PhotovoltaicThermalCollectors.cc | 2 +- src/EnergyPlus/PipeHeatTransfer.cc | 8 +- src/EnergyPlus/Plant/EquipAndOperations.cc | 10 +- src/EnergyPlus/Plant/Loop.cc | 8 +- src/EnergyPlus/Plant/LoopSide.cc | 10 +- src/EnergyPlus/Plant/PlantManager.cc | 26 +- src/EnergyPlus/PlantCentralGSHP.cc | 32 +- src/EnergyPlus/PlantChillers.cc | 78 +- .../PlantComponentTemperatureSources.cc | 6 +- src/EnergyPlus/PlantCondLoopOperation.cc | 4 +- .../PlantHeatExchangerFluidToFluid.cc | 20 +- src/EnergyPlus/PlantLoadProfile.cc | 20 +- src/EnergyPlus/PlantLoopHeatPumpEIR.cc | 40 +- src/EnergyPlus/PlantPipingSystemsManager.cc | 10 +- src/EnergyPlus/PlantPressureSystem.cc | 8 +- src/EnergyPlus/PlantUtilities.cc | 4 +- src/EnergyPlus/PondGroundHeatExchanger.cc | 32 +- src/EnergyPlus/PoweredInductionUnits.cc | 19 +- src/EnergyPlus/Pumps.cc | 22 +- src/EnergyPlus/RefrigeratedCase.cc | 172 +- src/EnergyPlus/ReportCoilSelection.cc | 16 +- src/EnergyPlus/RoomAirModelUserTempPattern.cc | 2 +- src/EnergyPlus/SetPointManager.cc | 2 +- src/EnergyPlus/SimulationManager.cc | 2 - src/EnergyPlus/SingleDuct.cc | 14 +- src/EnergyPlus/SolarCollectors.cc | 24 +- src/EnergyPlus/StandardRatings.cc | 4 +- src/EnergyPlus/SteamBaseboardRadiator.cc | 19 +- src/EnergyPlus/SteamCoils.cc | 43 +- src/EnergyPlus/SurfaceGroundHeatExchanger.cc | 9 +- src/EnergyPlus/SwimmingPool.cc | 8 +- src/EnergyPlus/UnitHeater.cc | 14 +- src/EnergyPlus/UnitVentilator.cc | 22 +- src/EnergyPlus/UnitarySystem.cc | 36 +- src/EnergyPlus/UserDefinedComponents.cc | 16 +- src/EnergyPlus/VariableSpeedCoils.cc | 28 +- src/EnergyPlus/VentilatedSlab.cc | 17 +- src/EnergyPlus/WaterCoils.cc | 4 +- src/EnergyPlus/WaterThermalTanks.cc | 110 +- src/EnergyPlus/WaterToAirHeatPump.cc | 92 +- src/EnergyPlus/WaterToAirHeatPumpSimple.cc | 10 +- src/EnergyPlus/WaterUse.cc | 2 +- src/EnergyPlus/api/EnergyPlusPgm.cc | 2 +- src/EnergyPlus/api/func.cc | 28 +- tst/EnergyPlus/unit/BoilerHotWater.unit.cc | 4 +- tst/EnergyPlus/unit/ChillerAbsorption.unit.cc | 12 +- .../unit/ChillerExhaustAbsorption.unit.cc | 2 +- .../unit/Fixtures/EnergyPlusFixture.cc | 6 +- tst/EnergyPlus/unit/FluidProperties.unit.cc | 46 +- .../unit/HVACVariableRefrigerantFlow.unit.cc | 12 +- .../unit/LowTempRadiantSystem.unit.cc | 16 +- tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc | 12 +- .../unit/OutsideEnergySources.unit.cc | 12 +- tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc | 8 +- tst/EnergyPlus/unit/PlantLoadProfile.unit.cc | 12 +- tst/EnergyPlus/unit/SetPointManager.unit.cc | 4 +- tst/EnergyPlus/unit/UnitHeater.unit.cc | 6 +- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 2 +- tst/EnergyPlus/unit/WaterCoils.unit.cc | 50 +- tst/EnergyPlus/unit/WaterThermalTanks.unit.cc | 10 +- .../unit/WaterToAirHeatPump.unit.cc | 114 +- 116 files changed, 3326 insertions(+), 3204 deletions(-) diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc index 16a97ba7cbf..2db751c59d2 100644 --- a/src/EnergyPlus/AirLoopHVACDOAS.cc +++ b/src/EnergyPlus/AirLoopHVACDOAS.cc @@ -889,7 +889,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:HEATING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_HeatCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", CompName, ErrorsFound); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -903,7 +903,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:COOLING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water", CompName, ErrorsFound); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -918,7 +918,7 @@ namespace AirLoopHVACDOAS { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", CompName, ErrorsFound); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc index 1eabcdf2ffa..5afba936626 100644 --- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc +++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc @@ -66,12 +66,12 @@ Real64 CoolingWaterDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _or this->autoSizedValue = _originalValue; } else { if (this->termUnitIU) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc index 1a6761c9818..4725b24c5d1 100644 --- a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc +++ b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc @@ -88,12 +88,12 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (DesCoilLoad >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizCoolDeltaT > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -120,12 +120,12 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (this->curOASysNum > 0) CoilDesWaterDeltaT *= 0.5; if (this->dataCapacityUsedForSizing >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && CoilDesWaterDeltaT > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc index ce84da3ffc6..336dc37c5d3 100644 --- a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc +++ b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc @@ -69,12 +69,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = _originalValue; } else { if (this->termUnitSingDuct && (this->curTermUnitSizingNum > 0)) { - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -82,12 +82,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho; state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(state, this->compName, this->compType, 1.0); } else if ((this->termUnitPIU || this->termUnitIU) && (this->curTermUnitSizingNum > 0)) { - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -95,12 +95,12 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho * this->termUnitSizing(this->curTermUnitSizingNum).ReheatLoadMult; } else if (this->zoneEqFanCoil || this->zoneEqUnitHeater) { - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc index 30e724a0a60..823f2c00aa3 100644 --- a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc +++ b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc @@ -93,12 +93,12 @@ Real64 HeatingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (DesCoilLoad >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizHeatDeltaT > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -123,12 +123,12 @@ Real64 HeatingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue, if (this->dataCapacityUsedForSizing >= HVAC::SmallLoad) { if (this->dataWaterLoopNum > 0 && this->dataWaterLoopNum <= (int)state.dataPlnt->PlantLoop.size() && this->dataWaterCoilSizHeatDeltaT > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc index a0193390ae9..342293b358a 100644 --- a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc +++ b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc @@ -72,12 +72,12 @@ Real64 WaterHeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalVa Real64 CoilOutHumRat = 0.0; if ((this->termUnitSingDuct || this->termUnitPIU || this->termUnitIU) && (this->curTermUnitSizingNum > 0)) { DesMassFlow = this->termUnitSizing(this->curTermUnitSizingNum).MaxHWVolFlow; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, @@ -85,12 +85,12 @@ Real64 WaterHeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalVa NominalCapacityDes = DesMassFlow * this->dataWaterCoilSizHeatDeltaT * Cp * rho; } else if (this->zoneEqFanCoil || this->zoneEqUnitHeater) { DesMassFlow = this->zoneEqSizing(this->curZoneEqNum).MaxHWVolFlow; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, this->callingRoutine); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->dataWaterLoopNum).FluidIndex, diff --git a/src/EnergyPlus/BaseboardRadiator.cc b/src/EnergyPlus/BaseboardRadiator.cc index 2f448c4674c..62ee9c5446a 100644 --- a/src/EnergyPlus/BaseboardRadiator.cc +++ b/src/EnergyPlus/BaseboardRadiator.cc @@ -95,8 +95,8 @@ namespace BaseboardRadiator { // Use statements for access to subroutines in other modules using namespace ScheduleManager; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyRhoAirFnPbTdbW; diff --git a/src/EnergyPlus/BoilerSteam.cc b/src/EnergyPlus/BoilerSteam.cc index 97f96a35edc..2d6b3a82184 100644 --- a/src/EnergyPlus/BoilerSteam.cc +++ b/src/EnergyPlus/BoilerSteam.cc @@ -267,10 +267,10 @@ namespace BoilerSteam { "Hot Steam Nodes"); if (SteamFluidIndex == 0 && BoilerNum == 1) { - SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); + SteamFluidIndex = FluidProperties::GetRefrigNum(state, fluidNameSteam); // Steam is a refrigerant? if (SteamFluidIndex == 0) { - ShowSevereError( - state, format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); + ShowSevereError( + state, format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError(state, "Steam Properties not found; Steam Fluid Properties must be included in the input file."); ErrorsFound = true; } @@ -307,13 +307,13 @@ namespace BoilerSteam { int BoilerInletNode = this->BoilerInletNodeNum; Real64 EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 1.0, this->FluidIndex, RoutineName); Real64 EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); Real64 LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; Real64 CpWater = - Fluid::GetSatSpecificHeatRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, fluidNameSteam, this->TempUpLimitBoilerOut, 0.0, this->FluidIndex, RoutineName); this->DesMassFlowRate = this->NomCap / (LatentEnthSteam + CpWater * (this->TempUpLimitBoilerOut - state.dataLoopNodes->Node(BoilerInletNode).Temp)); @@ -500,11 +500,11 @@ namespace BoilerSteam { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { Real64 SizingTemp = this->TempUpLimitBoilerOut; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 1.0, this->FluidIndex, RoutineName); + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); Real64 LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; - Real64 CpWater = Fluid::GetSatSpecificHeatRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); + Real64 CpWater = FluidProperties::GetSatSpecificHeatRefrig(state, fluidNameSteam, SizingTemp, 0.0, this->FluidIndex, RoutineName); tmpNomCap = (CpWater * SteamDensity * this->SizFac * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate + state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate * SteamDensity * LatentEnthSteam); @@ -677,7 +677,7 @@ namespace BoilerSteam { // Set the current load equal to the boiler load this->BoilerLoad = MyLoad; - this->BoilerPressCheck = Fluid::GetSatPressureRefrig(state, fluidNameSteam, this->BoilerOutletTemp, this->FluidIndex, RoutineName); + this->BoilerPressCheck = FluidProperties::GetSatPressureRefrig(state, fluidNameSteam, this->BoilerOutletTemp, this->FluidIndex, RoutineName); if ((this->BoilerPressCheck) > this->BoilerMaxOperPress) { if (this->PressErrIndex == 0) { @@ -697,7 +697,7 @@ namespace BoilerSteam { "[Pa]"); } - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp, 0.0, this->FluidIndex, RoutineName); if (state.dataPlnt->PlantLoop(this->plantLoc.loopNum).LoopSide(this->plantLoc.loopSideNum).FlowLock == @@ -717,9 +717,9 @@ namespace BoilerSteam { this->BoilerOutletTemp = BoilerDeltaTemp + state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; Real64 const EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + (CpWater * BoilerDeltaTemp)); @@ -755,9 +755,9 @@ namespace BoilerSteam { break; } Real64 const EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerLoad = (this->BoilerMassFlowRate * LatentEnthSteam); @@ -774,9 +774,9 @@ namespace BoilerSteam { } Real64 const EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; this->BoilerLoad = std::abs(this->BoilerMassFlowRate * LatentEnthSteam) + std::abs(this->BoilerMassFlowRate * CpWater * BoilerDeltaTemp); @@ -799,9 +799,9 @@ namespace BoilerSteam { } Real64 const EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; BoilerDeltaTemp = this->BoilerOutletTemp - state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + CpWater * BoilerDeltaTemp); @@ -816,9 +816,9 @@ namespace BoilerSteam { this->BoilerLoad = this->NomCap; Real64 const EnthSteamOutDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 1.0, this->FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, this->BoilerOutletTemp, 0.0, this->FluidIndex, RoutineName); Real64 const LatentEnthSteam = EnthSteamOutDry - EnthSteamOutWet; BoilerDeltaTemp = this->BoilerOutletTemp - state.dataLoopNodes->Node(this->BoilerInletNodeNum).Temp; this->BoilerMassFlowRate = this->BoilerLoad / (LatentEnthSteam + CpWater * BoilerDeltaTemp); diff --git a/src/EnergyPlus/Boilers.cc b/src/EnergyPlus/Boilers.cc index fbc339adbe9..d76186b5476 100644 --- a/src/EnergyPlus/Boilers.cc +++ b/src/EnergyPlus/Boilers.cc @@ -507,7 +507,7 @@ void BoilerSpecs::oneTimeInit(EnergyPlusData &state) void BoilerSpecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("BoilerSpecs::initEachEnvironment"); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -624,12 +624,12 @@ void BoilerSpecs::SizeBoiler(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -815,7 +815,7 @@ void BoilerSpecs::CalcBoilerModel(EnergyPlusData &state, Real64 const TempUpLimitBout = this->TempUpLimitBoilerOut; // C - boiler high temperature limit Real64 const BoilerMassFlowRateMax = this->DesMassFlowRate; // Max Design Boiler Mass Flow Rate converted from Volume Flow Rate - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(BoilerInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/CTElectricGenerator.cc b/src/EnergyPlus/CTElectricGenerator.cc index 42d25551956..db8b1b92d94 100644 --- a/src/EnergyPlus/CTElectricGenerator.cc +++ b/src/EnergyPlus/CTElectricGenerator.cc @@ -555,7 +555,7 @@ namespace CTElectricGenerator { int heatRecInNode = this->HeatRecInletNodeNum; heatRecInTemp = state.dataLoopNodes->Node(heatRecInNode).Temp; - heatRecCp = Fluid::GetSpecificHeatGlycol(state, + heatRecCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -810,7 +810,7 @@ namespace CTElectricGenerator { int HeatRecOutletNode = this->HeatRecOutletNodeNum; // size mass flow rate - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChilledCeilingPanelSimple.cc b/src/EnergyPlus/ChilledCeilingPanelSimple.cc index 537951000a7..811b5aead15 100644 --- a/src/EnergyPlus/ChilledCeilingPanelSimple.cc +++ b/src/EnergyPlus/ChilledCeilingPanelSimple.cc @@ -830,7 +830,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons // set design mass flow rates if (thisCP.WaterInletNode > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -845,7 +845,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons if (state.dataGlobal->BeginEnvrnFlag && thisCP.MyEnvrnFlag) { // Initialize - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -857,7 +857,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons ThisInNode.Temp = 7.0; - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, ThisInNode.Temp, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -1032,12 +1032,12 @@ void SizeCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum) PlantUtilities::MyPlantSizingIndex(state, CompType, thisCP.Name, thisCP.WaterInletNode, thisCP.WaterOutletNode, ErrorsFound); if (PltSizCoolNum > 0) { if (DesCoilLoad >= HVAC::SmallLoad) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(thisCP.plantLoc.loopNum).FluidIndex, @@ -1290,7 +1290,7 @@ void CoolingPanelParams::CalcCoolingPanel(EnergyPlusData &state, int const Cooli if (QZnReq < -HVAC::SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) && (CoolingPanelOn)) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, waterInletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1375,7 +1375,7 @@ void CoolingPanelParams::CalcCoolingPanel(EnergyPlusData &state, int const Cooli if (CoolingPanelOn) { // Now simulate the system... - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, waterInletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerAbsorption.cc b/src/EnergyPlus/ChillerAbsorption.cc index b18c7dd084b..879e1725eda 100644 --- a/src/EnergyPlus/ChillerAbsorption.cc +++ b/src/EnergyPlus/ChillerAbsorption.cc @@ -385,7 +385,7 @@ void GetBLASTAbsorberInput(EnergyPlusData &state) state.dataIPShortCut->cAlphaArgs(7), "Hot Water Nodes"); } else { - thisChiller.SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); + thisChiller.SteamFluidIndex = FluidProperties::GetRefrigNum(state, fluidNameSteam); thisChiller.GeneratorInletNodeNum = NodeInputManager::GetOnlySingleNode(state, state.dataIPShortCut->cAlphaArgs(6), ErrorsFound, @@ -755,7 +755,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) constexpr const char *RoutineName("BLASTAbsorberSpecs::initEachEnvironment"); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -765,7 +765,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -779,7 +779,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) if (this->GeneratorInletNodeNum > 0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -791,7 +791,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) this->QGenerator = (this->SteamLoadCoef[0] + this->SteamLoadCoef[1] + this->SteamLoadCoef[2]) * this->NomCap; // dry enthalpy of steam (quality = 1) - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -799,7 +799,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) calcChillerAbsorption + this->Name); // wet enthalpy of steam (quality = 0) - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -810,7 +810,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; int curWaterIndex = waterIndex; Real64 CpWater = - Fluid::GetDensityGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); + FluidProperties::GetDensityGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); this->GenMassFlowRateMax = this->QGenerator / (HfgSteam + CpWater * SteamDeltaT); } @@ -952,13 +952,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1120,13 +1120,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { // QCondenser = QEvaporator + QGenerator + PumpingPower - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1198,13 +1198,13 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water)) { if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); Real64 SteamDeltaT = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); - Real64 RhoWater = Fluid::GetDensityGlycol(state, + Real64 RhoWater = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1259,25 +1259,25 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) } } else { constexpr const char *RoutineNameLong("SizeAbsorptionChiller"); - Real64 SteamDensity = Fluid::GetSatDensityRefrig( + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, this->SteamFluidIndex, RoutineNameLong); Real64 SteamDeltaT = state.dataSize->PlantSizData(PltSizSteamNum).DeltaT; Real64 GeneratorOutletTemp = state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp - SteamDeltaT; - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, this->SteamFluidIndex, moduleObjectType + this->Name); - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 0.0, this->SteamFluidIndex, moduleObjectType + this->Name); int curWaterIndex = waterIndex; - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, curWaterIndex, RoutineName); + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, curWaterIndex, RoutineName); Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; this->SteamMassFlowRate = (this->NomCap * SteamInputRatNom) / ((HfgSteam) + (SteamDeltaT * CpWater)); tmpGeneratorVolFlowRate = this->SteamMassFlowRate / SteamDensity; @@ -1366,12 +1366,12 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) this->GeneratorDeltaTemp = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1485,7 +1485,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R Real64 TempEvapOut = state.dataLoopNodes->Node(this->EvapOutletNodeNum).Temp; - Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1715,7 +1715,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R this->QCondenser = this->QEvaporator + this->QGenerator + this->PumpingPower; - CpFluid = Fluid::GetSpecificHeatGlycol(state, + CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->CondInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1736,7 +1736,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { Real64 GenMassFlowRate = 0.0; // Hot water plant is used for the generator - CpFluid = Fluid::GetSpecificHeatGlycol(state, + CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, state.dataPlnt->PlantLoop(GenPlantLoc.loopNum).FluidIndex, @@ -1771,7 +1771,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R } else { // using a steam plant for the generator // enthalpy of dry steam at generator inlet - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -1779,7 +1779,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R calcChillerAbsorption + this->Name); // enthalpy of wet steam at generator inlet - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -1790,7 +1790,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; int curWaterIndex = waterIndex; CpFluid = - Fluid::GetSpecificHeatGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); + FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, SteamOutletTemp, curWaterIndex, calcChillerAbsorption + this->Name); this->SteamMassFlowRate = this->QGenerator / (HfgSteam + CpFluid * SteamDeltaT); PlantUtilities::SetComponentFlowRate( state, this->SteamMassFlowRate, this->GeneratorInletNodeNum, this->GeneratorOutletNodeNum, this->GenPlantLoc); @@ -1800,7 +1800,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R this->SteamOutletEnthalpy = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Enthalpy; } else { this->GenOutletTemp = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp - SteamDeltaT; - this->SteamOutletEnthalpy = Fluid::GetSatEnthalpyRefrig( + this->SteamOutletEnthalpy = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, this->GenOutletTemp, 0.0, this->SteamFluidIndex, moduleObjectType + this->Name); this->SteamOutletEnthalpy -= CpFluid * SteamDeltaT; } diff --git a/src/EnergyPlus/ChillerElectricASHRAE205.cc b/src/EnergyPlus/ChillerElectricASHRAE205.cc index cdbe6631f0c..b3413b28b48 100644 --- a/src/EnergyPlus/ChillerElectricASHRAE205.cc +++ b/src/EnergyPlus/ChillerElectricASHRAE205.cc @@ -596,7 +596,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag this->EquipFlowCtrl = DataPlant::CompData::getPlantComponent(state, this->CWPlantLoc).FlowCtrl; if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -606,7 +606,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -617,7 +617,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag } // Set mass flow rates at Oil Cooler and Aux Equipment nodes if (this->OilCoolerInletNode) { - Real64 rho_oil_cooler = Fluid::GetDensityGlycol(state, + Real64 rho_oil_cooler = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidIndex, @@ -626,7 +626,7 @@ void ASHRAE205ChillerSpecs::initialize(EnergyPlusData &state, bool const RunFlag PlantUtilities::InitComponentNodes(state, 0.0, this->OilCoolerMassFlowRate, this->OilCoolerInletNode, this->OilCoolerOutletNode); } if (this->AuxiliaryHeatInletNode) { - Real64 rho_aux = Fluid::GetDensityGlycol(state, + Real64 rho_aux = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidIndex, @@ -771,12 +771,12 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -878,13 +878,13 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1256,7 +1256,7 @@ void ASHRAE205ChillerSpecs::findEvaporatorMassFlowRate(EnergyPlusData &state, Re } } // This is the end of the FlowLock Block - const Real64 rho = Fluid::GetDensityGlycol(state, + const Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1391,7 +1391,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo return; } - Real64 CpEvap = Fluid::GetSpecificHeatGlycol(state, + Real64 CpEvap = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1508,7 +1508,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo // Energy balance on the chiller system gives the amount of heat lost to the ambient zone this->AmbientZoneGain = this->QEvaporator + this->Power - (this->QCondenser + QExternallyCooled); - Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, + Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1521,7 +1521,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo PlantUtilities::SetComponentFlowRate( state, this->OilCoolerMassFlowRate, this->OilCoolerInletNode, this->OilCoolerOutletNode, this->OCPlantLoc); - Real64 CpOilCooler = Fluid::GetSpecificHeatGlycol(state, + Real64 CpOilCooler = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->OilCoolerInletNode).Temp, state.dataPlnt->PlantLoop(this->OCPlantLoc.loopNum).FluidIndex, @@ -1539,7 +1539,7 @@ void ASHRAE205ChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, boo PlantUtilities::SetComponentFlowRate( state, this->AuxiliaryMassFlowRate, this->AuxiliaryHeatInletNode, this->AuxiliaryHeatOutletNode, this->AHPlantLoc); - Real64 CpAux = Fluid::GetSpecificHeatGlycol(state, + Real64 CpAux = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->AuxiliaryHeatInletNode).Temp, state.dataPlnt->PlantLoop(this->AHPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerElectricEIR.cc b/src/EnergyPlus/ChillerElectricEIR.cc index 3d43f2dfb25..0c771b352b6 100644 --- a/src/EnergyPlus/ChillerElectricEIR.cc +++ b/src/EnergyPlus/ChillerElectricEIR.cc @@ -1152,7 +1152,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) static constexpr std::string_view RoutineName("ElectricEIRChillerSpecs::initEachEnvironment"); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1164,7 +1164,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1190,7 +1190,7 @@ void ElectricEIRChillerSpecs::initEachEnvironment(EnergyPlusData &state) } if (this->HeatRecActive) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1405,13 +1405,13 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1468,12 +1468,12 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1995,7 +1995,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b if (DataPlant::CompData::getPlantComponent(state, this->CWPlantLoc).CurOpSchemeType == DataPlant::OpScheme::CompSetPtBased) { // Calculate water side load - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2028,7 +2028,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b PartLoadRat = max(0.0, min(std::abs(MyLoad) / AvailChillerCap, this->MaxPartLoadRat)); } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2300,7 +2300,7 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovered); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2369,14 +2369,14 @@ void ElectricEIRChillerSpecs::calcHeatRecovery(EnergyPlusData &state, Real64 heatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, RoutineName); Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = Fluid::GetSpecificHeatGlycol(state, + CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/ChillerExhaustAbsorption.cc b/src/EnergyPlus/ChillerExhaustAbsorption.cc index 15db9f07583..e29f2a10fbf 100644 --- a/src/EnergyPlus/ChillerExhaustAbsorption.cc +++ b/src/EnergyPlus/ChillerExhaustAbsorption.cc @@ -949,7 +949,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) if (this->isWaterCooled) { // init max available condenser water flow rate if (this->CDPlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -963,7 +963,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) } if (this->HWPlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -976,7 +976,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->DesHeatMassFlowRate, HeatInletNode, HeatOutletNode); if (this->CWPlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1066,12 +1066,12 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1296,12 +1296,12 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1542,13 +1542,13 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) Real64 lExhaustInFlow = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).MassFlowRate; Real64 lExhaustAirHumRat = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).HumRat; - Real64 Cp_CW = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp_CW = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); if (this->CDPlantLoc.loopNum > 0) { - Cp_CD = Fluid::GetSpecificHeatGlycol(state, + Cp_CD = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1906,7 +1906,7 @@ void ExhaustAbsorberSpecs::calcHeater(EnergyPlusData &state, Real64 &MyLoad, boo } else { Real64 const Cp_HW = - Fluid::GetSpecificHeatGlycol(state, hwPlantLoop.FluidName, heatReturnNode.Temp, hwPlantLoop.FluidIndex, RoutineName); + FluidProperties::GetSpecificHeatGlycol(state, hwPlantLoop.FluidName, heatReturnNode.Temp, hwPlantLoop.FluidIndex, RoutineName); // Determine available heating capacity using the current cooling load lAvailableHeatingCapacity = this->NomHeatCoolRatio * this->NomCoolingCap * diff --git a/src/EnergyPlus/ChillerGasAbsorption.cc b/src/EnergyPlus/ChillerGasAbsorption.cc index effb063112e..6cb26c946db 100644 --- a/src/EnergyPlus/ChillerGasAbsorption.cc +++ b/src/EnergyPlus/ChillerGasAbsorption.cc @@ -948,7 +948,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) if (this->isWaterCooled) { // init max available condenser water flow rate if (this->CDplantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -962,7 +962,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) } if (this->HWplantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, @@ -975,7 +975,7 @@ void GasAbsorberSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->DesHeatMassFlowRate, HeatInletNode, HeatOutletNode); if (this->CWplantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1059,12 +1059,12 @@ void GasAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1288,12 +1288,12 @@ void GasAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, this->TempDesCondReturn, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -1532,7 +1532,7 @@ void GasAbsorberSpecs::calculateChiller(EnergyPlusData &state, Real64 &MyLoad) Real64 ChillDeltaTemp = std::abs(lChillReturnTemp - ChillSupplySetPointTemp); // local fluid specific heat for chilled water - Real64 Cp_CW = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp_CW = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CWplantLoc.loopNum).FluidIndex, @@ -1540,7 +1540,7 @@ void GasAbsorberSpecs::calculateChiller(EnergyPlusData &state, Real64 &MyLoad) // local fluid specific heat for condenser water Real64 Cp_CD = 0; // putting this here as a dummy initialization to hush the compiler warning, in real runs this value should never be used if (this->CDplantLoc.loopNum > 0) { - Cp_CD = Fluid::GetSpecificHeatGlycol(state, + Cp_CD = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidName, lChillReturnTemp, state.dataPlnt->PlantLoop(this->CDplantLoc.loopNum).FluidIndex, @@ -1854,7 +1854,7 @@ void GasAbsorberSpecs::calculateHeater(EnergyPlusData &state, Real64 &MyLoad, bo LoopNum = this->HWplantLoc.loopNum; LoopSideNum = this->HWplantLoc.loopSideNum; - Cp_HW = Fluid::GetSpecificHeatGlycol( + Cp_HW = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, lHotWaterReturnTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); lCoolElectricPower = this->CoolElectricPower; diff --git a/src/EnergyPlus/ChillerIndirectAbsorption.cc b/src/EnergyPlus/ChillerIndirectAbsorption.cc index 4652293bf4f..9a60e43c688 100644 --- a/src/EnergyPlus/ChillerIndirectAbsorption.cc +++ b/src/EnergyPlus/ChillerIndirectAbsorption.cc @@ -396,7 +396,7 @@ void GetIndirectAbsorberInput(EnergyPlusData &state) state.dataIPShortCut->cAlphaArgs(10), "Hot Water Nodes"); } else { - thisChiller.SteamFluidIndex = Fluid::FindRefrigerant(state, fluidNameSteam); + thisChiller.SteamFluidIndex = FluidProperties::GetRefrigNum(state, fluidNameSteam); thisChiller.GeneratorInletNodeNum = NodeInputManager::GetOnlySingleNode(state, state.dataIPShortCut->cAlphaArgs(9), ErrorsFound, @@ -891,7 +891,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real // Initialize Supply Side Variables if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -901,7 +901,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -917,7 +917,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -925,7 +925,7 @@ void IndirectAbsorberSpecs::initialize(EnergyPlusData &state, bool RunFlag, Real this->GenMassFlowRateMax = rho * this->GeneratorVolFlowRate; } else { - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -1052,13 +1052,13 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1240,13 +1240,13 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { // QCondenser = QEvaporator + QGenerator + PumpingPower - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1331,14 +1331,14 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water)) { if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); Real64 SteamDeltaT = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); - Real64 RhoWater = Fluid::GetDensityGlycol(state, + Real64 RhoWater = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1395,7 +1395,7 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) } } } else { - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, @@ -1405,7 +1405,7 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) Real64 GeneratorOutletTemp = state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp - SteamDeltaT; // dry enthalpy of steam (quality = 1) - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 1.0, @@ -1413,14 +1413,14 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) std::string{SizeChillerAbsorptionIndirect} + this->Name); // wet enthalpy of steam (quality = 0) - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataSize->PlantSizData(PltSizSteamNum).ExitTemp, 0.0, this->SteamFluidIndex, std::string{SizeChillerAbsorptionIndirect} + this->Name); Real64 CpWater = - Fluid::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, const_cast(waterIndex), RoutineName); + FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, GeneratorOutletTemp, const_cast(waterIndex), RoutineName); Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; // calculate the mass flow rate through the generator Real64 SteamMassFlowRate = (tmpNomCap * SteamInputRatNom) / ((HfgSteam) + (SteamDeltaT * CpWater)); @@ -1519,12 +1519,12 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { this->GeneratorDeltaTemp = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -1717,7 +1717,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // C - Evaporator low temp. limit cut off Real64 TempLowLimitEout = this->TempLowLimitEvapOut; - Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1987,7 +1987,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad this->QCondenser = this->QEvaporator + this->QGenerator + this->PumpingPower; - CpFluid = Fluid::GetSpecificHeatGlycol(state, + CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2007,7 +2007,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // Hot water plant is used for the generator if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - CpFluid = Fluid::GetSpecificHeatGlycol(state, + CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).FluidIndex, @@ -2034,7 +2034,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad } else { // using a steam plant for the generator // enthalpy of dry steam at generator inlet - Real64 EnthSteamOutDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 1.0, @@ -2042,7 +2042,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad std::string{calcChillerAbsorptionIndirect} + this->Name); // enthalpy of wet steam at generator inlet - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, @@ -2057,7 +2057,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad // heat of vaporization of steam Real64 HfgSteam = EnthSteamOutDry - EnthSteamOutWet; - CpFluid = Fluid::GetSpecificHeatGlycol( + CpFluid = FluidProperties::GetSpecificHeatGlycol( state, fluidNameWater, SteamOutletTemp, const_cast(waterIndex), std::string{calcChillerAbsorptionIndirect} + this->Name); this->GenMassFlowRate = this->QGenerator / (HfgSteam + CpFluid * SteamDeltaT); PlantUtilities::SetComponentFlowRate( @@ -2068,13 +2068,13 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad this->SteamOutletEnthalpy = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Enthalpy; } else { this->GenOutletTemp = state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp - SteamDeltaT; - this->SteamOutletEnthalpy = Fluid::GetSatEnthalpyRefrig(state, + this->SteamOutletEnthalpy = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, 0.0, this->SteamFluidIndex, std::string{LoopLossesChillerAbsorptionIndirect} + this->Name); - CpFluid = Fluid::GetSpecificHeatGlycol(state, + CpFluid = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, const_cast(waterIndex), @@ -2085,14 +2085,14 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad //************************* Loop Losses ***************************** // temperature of condensed steam leaving generator (after condensate trap) - Real64 TempWaterAtmPress = Fluid::GetSatTemperatureRefrig(state, + Real64 TempWaterAtmPress = FluidProperties::GetSatTemperatureRefrig(state, fluidNameSteam, state.dataEnvrn->OutBaroPress, this->SteamFluidIndex, std::string{LoopLossesChillerAbsorptionIndirect} + this->Name); // enthalpy of condensed steam leaving generator (after condensate trap) - Real64 EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthAtAtmPress = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempWaterAtmPress, 0.0, diff --git a/src/EnergyPlus/ChillerReformulatedEIR.cc b/src/EnergyPlus/ChillerReformulatedEIR.cc index 6b5d6d6210e..fced4b2388a 100644 --- a/src/EnergyPlus/ChillerReformulatedEIR.cc +++ b/src/EnergyPlus/ChillerReformulatedEIR.cc @@ -990,7 +990,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1002,7 +1002,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1027,7 +1027,7 @@ void ReformulatedEIRChillerSpecs::initialize(EnergyPlusData &state, bool const R } if (this->HeatRecActive) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1197,12 +1197,12 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) SizingEvapOutletTemp = state.dataSize->PlantSizData(PltSizNum).ExitTemp; SizingCondOutletTemp = state.dataSize->PlantSizData(PltSizCondNum).ExitTemp + state.dataSize->PlantSizData(PltSizCondNum).DeltaT; } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1263,12 +1263,12 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizNum > 0 && this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1607,13 +1607,13 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) } // Initialize condenser reference inlet temperature (not a user input) - Real64 Density = Fluid::GetDensityGlycol(state, + Real64 Density = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondOut, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol(state, + Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempRefCondOut, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1846,14 +1846,14 @@ void ReformulatedEIRChillerSpecs::calcHeatRecovery(EnergyPlusData &state, Real64 heatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, heatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, RoutineName); Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = Fluid::GetSpecificHeatGlycol(state, + CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2158,7 +2158,7 @@ void ReformulatedEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoa // This chiller is currently has only a water-cooled condenser // Calculate water side load - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2442,7 +2442,7 @@ void ReformulatedEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoa if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovery); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index 60a617f2384..bcc98409f3f 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -1789,7 +1789,7 @@ namespace CondenserLoopTowers { void CoolingTower::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("CoolingTower::initEachEnvironment"); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2481,12 +2481,12 @@ namespace CondenserLoopTowers { if (this->PerformanceInputMethod_Num == PIM::UFactor && (!this->HighSpeedTowerUAWasAutoSized)) { if (PltSizCondNum > 0) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2498,12 +2498,12 @@ namespace CondenserLoopTowers { Real64 AssumedDeltaT = DesTowerWaterDeltaT; Real64 AssumedExitTemp = DesTowerExitWaterTemp; - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AssumedExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AssumedExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2592,12 +2592,12 @@ namespace CondenserLoopTowers { } else { if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2692,12 +2692,12 @@ namespace CondenserLoopTowers { if (this->HighSpeedTowerUAWasAutoSized) { if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2791,12 +2791,12 @@ namespace CondenserLoopTowers { } else { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2911,12 +2911,12 @@ namespace CondenserLoopTowers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of delivered cooling but now is // a user input - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3094,12 +3094,12 @@ namespace CondenserLoopTowers { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of evap cooling but now is a // user input - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3193,12 +3193,12 @@ namespace CondenserLoopTowers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->TowerFreeConvNomCap > 0.0) { // nominal capacity doesn't include compressor heat; predefined factor was 1.25 W heat rejection per W of evap cooling but now user // input - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // 85F design exiting water temp - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3342,12 +3342,12 @@ namespace CondenserLoopTowers { state.dataCondenserLoopTowers->towers(this->VSTower).MaxWaterFlowRatio)); } - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, (this->DesignInletWB + this->DesignApproach + this->DesignRange), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, (this->DesignInletWB + this->DesignApproach + this->DesignRange), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3589,12 +3589,12 @@ namespace CondenserLoopTowers { if (PltSizCondNum > 0) { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3607,12 +3607,12 @@ namespace CondenserLoopTowers { } else { // PltSizCondNum = 0 if (!this->TowerInletCondsAutoSize) { // can use design data entered into tower object if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3870,21 +3870,21 @@ namespace CondenserLoopTowers { // now calcuate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { if (PltSizCondNum > 0) { // user has a plant sizing object - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); this->WaterTemp = DesTowerInletWaterTemp; } else { // probably no plant sizing object - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); this->WaterTemp = DesTowerInletWaterTemp; // 35.0; // design condition } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4033,12 +4033,12 @@ namespace CondenserLoopTowers { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4085,12 +4085,12 @@ namespace CondenserLoopTowers { } else { if (!this->TowerInletCondsAutoSize) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4207,12 +4207,12 @@ namespace CondenserLoopTowers { } // now calcuate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4322,12 +4322,12 @@ namespace CondenserLoopTowers { // get nominal capacity from PlantSizData(PltSizCondNum)%DeltaT and PlantSizData(PltSizCondNum)%DesVolFlowRate if (PltSizCondNum > 0) { if (PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4405,12 +4405,12 @@ namespace CondenserLoopTowers { } else { // UA and Air flow rate given, so find Nominal Cap from running model - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DesTowerExitWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -4837,7 +4837,7 @@ namespace CondenserLoopTowers { // output the fraction of the time step the fan is ON this->FanCyclingRatio = FanModeFrac; // Should this be water inlet node num????? - Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5080,7 +5080,7 @@ namespace CondenserLoopTowers { this->FanCyclingRatio = FanModeFrac; this->SpeedSelected = SpeedSel; - Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5227,7 +5227,7 @@ namespace CondenserLoopTowers { while (IncrNumCellFlag) { IncrNumCellFlag = false; // Initialize inlet node water properties - Real64 const WaterDensity = Fluid::GetDensityGlycol(state, + Real64 const WaterDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5361,7 +5361,7 @@ namespace CondenserLoopTowers { } // IF(OutletWaterTempOFF .GT. TempSetPoint)THEN } // IF(OutletWaterTempON .LT. TempSetPoint) ie if tower should not run at full capacity - Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5449,7 +5449,7 @@ namespace CondenserLoopTowers { Real64 constexpr Acc(1.e-3); // Accuracy of solver result static constexpr std::string_view RoutineName("calculateMerkelVariableSpeedTower"); - Real64 const CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -5731,7 +5731,7 @@ namespace CondenserLoopTowers { Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, this->AirPress, InletAirTemp, this->AirHumRat); // Density of air [kg/m3] Real64 AirMassFlowRate = AirFlowRate * AirDensity; // Mass flow rate of air [kg/s] Real64 CpAir = Psychrometrics::PsyCpAirFnW(this->AirHumRat); // Heat capacity of air [J/kg/K] - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->WaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -6252,7 +6252,7 @@ namespace CondenserLoopTowers { Real64 const TairAvg = (this->AirTemp + OutletAirTSat) / 2.0; // Amount of water evaporated, get density water at air temp or 4 C if too cold - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, max(TairAvg, 4.0), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -6265,7 +6265,7 @@ namespace CondenserLoopTowers { } } else if (this->EvapLossMode == EvapLoss::UserFactor) { - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index 2931bffce2d..5543fd3f191 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -117,7 +117,7 @@ EnergyPlusData::EnergyPlusData() this->dataFans = std::make_unique(); this->dataFaultsMgr = std::make_unique(); this->dataFluidCoolers = std::make_unique(); - this->dataFluid = std::make_unique(); + this->dataFluidProperties = std::make_unique(); this->dataFourPipeBeam = std::make_unique(); this->dataFuelCellElectGen = std::make_unique(); this->dataFurnaces = std::make_unique(); @@ -372,7 +372,7 @@ void EnergyPlusData::clear_state() this->dataFans->clear_state(); this->dataFaultsMgr->clear_state(); this->dataFluidCoolers->clear_state(); - this->dataFluid->clear_state(); + this->dataFluidProperties->clear_state(); this->dataFourPipeBeam->clear_state(); this->dataFuelCellElectGen->clear_state(); this->dataFurnaces->clear_state(); @@ -574,7 +574,7 @@ void EnergyPlusData::init_state(EnergyPlusData &state) // do this in "topological" order meaning the first to go are the // objects that do not reference any other objects, like fluids, // schedules, curves, etc. - this->dataFluid->init_state(state); + this->dataFluidProperties->init_state(state); this->dataAirLoop->init_state(state); this->dataAirLoopHVACDOAS->init_state(state); diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index 95a4ea8da82..fd2afcdee23 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -390,7 +390,7 @@ struct EnergyPlusData : BaseGlobalStruct std::unique_ptr dataFans; std::unique_ptr dataFaultsMgr; std::unique_ptr dataFluidCoolers; - std::unique_ptr dataFluid; + std::unique_ptr dataFluidProperties; std::unique_ptr dataFourPipeBeam; std::unique_ptr dataFuelCellElectGen; std::unique_ptr dataFurnaces; diff --git a/src/EnergyPlus/DaylightingDevices.cc b/src/EnergyPlus/DaylightingDevices.cc index b8fecc5ce33..37a8942ad32 100644 --- a/src/EnergyPlus/DaylightingDevices.cc +++ b/src/EnergyPlus/DaylightingDevices.cc @@ -1400,7 +1400,7 @@ namespace Dayltg { // REFERENCES: na // Using/Aliasing - using Fluid::FindArrayIndex; // USEd code could be copied here to eliminate dependence on FluidProperties + using FluidProperties::FindArrayIndex; // USEd code could be copied here to eliminate dependence on FluidProperties // Return value Real64 InterpolatePipeTransBeam; diff --git a/src/EnergyPlus/DesiccantDehumidifiers.cc b/src/EnergyPlus/DesiccantDehumidifiers.cc index d567be8fcee..a9a3aafc4e0 100644 --- a/src/EnergyPlus/DesiccantDehumidifiers.cc +++ b/src/EnergyPlus/DesiccantDehumidifiers.cc @@ -475,7 +475,7 @@ namespace DesiccantDehumidifiers { if (desicDehum.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); desicDehum.MaxCoilFluidFlow *= SteamDensity; } @@ -984,7 +984,7 @@ namespace DesiccantDehumidifiers { desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, errFlag); if (desicDehum.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 SteamDensity = Fluid::GetSatDensityRefrig( + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, dehumidifierDesiccantNoFans); desicDehum.MaxCoilFluidFlow *= SteamDensity; } @@ -1654,7 +1654,7 @@ namespace DesiccantDehumidifiers { desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", desicDehum.RegenCoilName, ErrorFlag); if (desicDehum.MaxCoilFluidFlow > 0.0) { - Real64 FluidDensity = Fluid::GetDensityGlycol(state, + Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidIndex, @@ -1684,7 +1684,7 @@ namespace DesiccantDehumidifiers { if (desicDehum.MaxCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); desicDehum.MaxCoilFluidFlow *= FluidDensity; } } @@ -1770,7 +1770,7 @@ namespace DesiccantDehumidifiers { //} if (CoilMaxVolFlowRate != DataSizing::AutoSize) { Real64 FluidDensity = - Fluid::GetDensityGlycol(state, + FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).FluidIndex, @@ -1793,7 +1793,7 @@ namespace DesiccantDehumidifiers { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 FluidDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); desicDehum.MaxCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } } diff --git a/src/EnergyPlus/EvaporativeFluidCoolers.cc b/src/EnergyPlus/EvaporativeFluidCoolers.cc index d9841a04e1c..3e170a3c51e 100644 --- a/src/EnergyPlus/EvaporativeFluidCoolers.cc +++ b/src/EnergyPlus/EvaporativeFluidCoolers.cc @@ -1277,7 +1277,7 @@ namespace EvaporativeFluidCoolers { // Begin environment initializations if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1406,12 +1406,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UFactor && !this->HighSpeedEvapFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1481,12 +1481,12 @@ namespace EvaporativeFluidCoolers { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) this->HighSpeedFanPower = tmpHighSpeedFanPower; } else if (PltSizCondNum > 0) { if (state.dataSize->PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1586,12 +1586,12 @@ namespace EvaporativeFluidCoolers { "must be > 25.6 C if autosizing the Evaporative Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1714,12 +1714,12 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { // Standard Design Capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now a user input with 1.25 default - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 35.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1792,12 +1792,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1952,12 +1952,12 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedStandardDesignCapacity > 0.0) { // Standard design capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now user input with default 1.25 - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2014,12 +2014,12 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity && this->Type == DataPlant::PlantEquipmentType::EvapFluidCooler_TwoSpd) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedUserSpecifiedDesignCapacity > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2279,7 +2279,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num????? - CpWater = Fluid::GetSpecificHeatGlycol(state, + CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2404,7 +2404,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num?? - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNode).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2457,7 +2457,7 @@ namespace EvaporativeFluidCoolers { Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, this->inletConds.AirPress, InletAirTemp, this->inletConds.AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(this->inletConds.AirHumRat); - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2556,7 +2556,7 @@ namespace EvaporativeFluidCoolers { Real64 TairAvg = (this->inletConds.AirTemp + OutletAirTSat) / 2.0; // Amount of water evaporated - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TairAvg, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2568,7 +2568,7 @@ namespace EvaporativeFluidCoolers { } } else if (this->EvapLossMode == EvapLoss::ByUserFactor) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2762,7 +2762,7 @@ namespace EvaporativeFluidCoolers { this->setupOutputVars(state); this->FluidIndex = state.dataPlnt->PlantLoop(state.dataSize->CurLoopNum).FluidIndex; - std::string FluidName = Fluid::GetGlycolNameByIndex(state, this->FluidIndex); + std::string FluidName = FluidProperties::GetGlycolNameByIndex(state, this->FluidIndex); if (Util::SameString(this->PerformanceInputMethod, "STANDARDDESIGNCAPACITY")) { this->PerformanceInputMethod_Num = PIM::StandardDesignCapacity; diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc index d1fa183f8f1..2b9680775cc 100644 --- a/src/EnergyPlus/FanCoilUnits.cc +++ b/src/EnergyPlus/FanCoilUnits.cc @@ -1083,7 +1083,7 @@ namespace FanCoilUnits { fanCoil.OutAirMassFlow = RhoAir * fanCoil.OutAirVolFlow; if (fanCoil.HCoilType_Num == HCoil::Water) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, @@ -1092,7 +1092,7 @@ namespace FanCoilUnits { fanCoil.MinHotWaterFlow = rho * fanCoil.MinHotWaterVolFlow; } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, @@ -1630,12 +1630,12 @@ namespace FanCoilUnits { } fanCoil.DesHeatingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, RoutineNameNoSpace); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).FluidIndex, @@ -1815,12 +1815,12 @@ namespace FanCoilUnits { } fanCoil.DesCoolingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, RoutineNameNoSpace); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index ca88e72f098..9f8b613ddef 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -851,7 +851,7 @@ void FluidCoolerspecs::oneTimeInit_new(EnergyPlusData &state) void FluidCoolerspecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("FluidCoolerspecs::initEachEnvironment"); - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1008,12 +1008,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::U_FACTOR && this->HighSpeedFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1054,12 +1054,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "Setpoint must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1143,12 +1143,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "Setpoint must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1225,12 +1225,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) "must be > design inlet air dry-bulb temp if autosizing the Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1339,12 +1339,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::NOMINAL_CAPACITY) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1523,12 +1523,12 @@ void FluidCoolerspecs::size(EnergyPlusData &state) } if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->FluidCoolerLowSpeedNomCap > 0.0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->DesignEnteringWaterTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1759,7 +1759,7 @@ void FluidCoolerspecs::calcSingleSpeed(EnergyPlusData &state) // Setpoint was not met, fluid cooler ran at full capacity this->FanPower = FanPowerOn; } - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1885,7 +1885,7 @@ void FluidCoolerspecs::calcTwoSpeed(EnergyPlusData &state) this->FanPower = FanPowerHigh; } } - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1928,7 +1928,7 @@ void CalcFluidCoolerOutlet( state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).AirHumRat); - Real64 CpWater = Fluid::GetSpecificHeatGlycol( + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).plantLoc.loopNum).FluidName, _InletWaterTemp, diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 3d2b82acb64..fceaee26c02 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -64,7 +64,7 @@ namespace EnergyPlus { -namespace Fluid { +namespace FluidProperties { // MODULE INFORMATION: // AUTHOR Mike Turner @@ -686,10 +686,10 @@ namespace Fluid { ++FluidNum; FluidNames(FluidNum).Name = Alphas(1); if (Util::SameString(Alphas(2), Refrig)) { - ++state.dataFluid->NumOfRefrigerants; + ++state.dataFluidProperties->NumOfRefrigerants; FluidNames(FluidNum).IsGlycol = false; } else if (Util::SameString(Alphas(2), Glycol)) { - ++state.dataFluid->NumOfGlycols; + ++state.dataFluidProperties->NumOfGlycols; FluidNames(FluidNum).IsGlycol = true; } else { ShowSevereError(state, format("{}{}=\"{}\", invalid type", RoutineName, CurrentModuleObject, Alphas(1))); @@ -702,75 +702,78 @@ namespace Fluid { ShowFatalError(state, format("{} Previous errors in input cause program termination.", RoutineName)); } - if (state.dataFluid->NumOfRefrigerants + 1 > 0) { - state.dataFluid->RefrigData.allocate(state.dataFluid->NumOfRefrigerants + 1); - state.dataFluid->RefrigUsed.allocate(state.dataFluid->NumOfRefrigerants + 1); - state.dataFluid->RefrigUsed = false; - state.dataFluid->RefrigErrorTracking.allocate(state.dataFluid->NumOfRefrigerants + 1); + if (state.dataFluidProperties->NumOfRefrigerants + 1 > 0) { + state.dataFluidProperties->RefrigData.allocate(state.dataFluidProperties->NumOfRefrigerants + 1); + state.dataFluidProperties->RefrigUsed.allocate(state.dataFluidProperties->NumOfRefrigerants + 1); + state.dataFluidProperties->RefrigUsed = false; + state.dataFluidProperties->RefrigErrorTracking.allocate(state.dataFluidProperties->NumOfRefrigerants + 1); } - if (state.dataFluid->NumOfGlycols > 0) { - state.dataFluid->GlyRawData.allocate(state.dataFluid->NumOfGlycols); + if (state.dataFluidProperties->NumOfGlycols > 0) { + state.dataFluidProperties->GlyRawData.allocate(state.dataFluidProperties->NumOfGlycols); } // Take the fluid names and assign them to the appropriate derived type - state.dataFluid->NumOfRefrigerants = 1; - state.dataFluid->NumOfGlycols = 0; - state.dataFluid->RefrigData(1).Name = "STEAM"; - state.dataFluid->RefrigUsed(1) = true; - state.dataFluid->RefrigErrorTracking(1).Name = "STEAM"; + state.dataFluidProperties->NumOfRefrigerants = 1; + state.dataFluidProperties->NumOfGlycols = 0; + state.dataFluidProperties->RefrigData(1).Name = "STEAM"; // Steam is a refrigerant? In which universe? + state.dataFluidProperties->RefrigData(1).Num = 1; + state.dataFluidProperties->RefrigUsed(1) = true; + state.dataFluidProperties->RefrigErrorTracking(1).Name = "STEAM"; for (int Loop = 1; Loop <= FluidNum; ++Loop) { if (!FluidNames(Loop).IsGlycol) { - ++state.dataFluid->NumOfRefrigerants; - state.dataFluid->RefrigData(state.dataFluid->NumOfRefrigerants).Name = FluidNames(Loop).Name; - state.dataFluid->RefrigErrorTracking(state.dataFluid->NumOfRefrigerants).Name = FluidNames(Loop).Name; + ++state.dataFluidProperties->NumOfRefrigerants; + state.dataFluidProperties->RefrigData(state.dataFluidProperties->NumOfRefrigerants).Name = FluidNames(Loop).Name; + state.dataFluidProperties->RefrigData(state.dataFluidProperties->NumOfRefrigerants).Num = state.dataFluidProperties->NumOfRefrigerants; + state.dataFluidProperties->RefrigErrorTracking(state.dataFluidProperties->NumOfRefrigerants).Name = FluidNames(Loop).Name; } else if (FluidNames(Loop).IsGlycol) { - ++state.dataFluid->NumOfGlycols; - state.dataFluid->GlyRawData(state.dataFluid->NumOfGlycols).Name = FluidNames(Loop).Name; + ++state.dataFluidProperties->NumOfGlycols; + state.dataFluidProperties->GlyRawData(state.dataFluidProperties->NumOfGlycols).Name = FluidNames(Loop).Name; + state.dataFluidProperties->GlyRawData(state.dataFluidProperties->NumOfGlycols).Num = state.dataFluidProperties->NumOfGlycols; } } FluidNames.deallocate(); - state.dataFluid->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; - state.dataFluid->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).NumHPoints = DefaultNumSteamTemps; - state.dataFluid->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; - state.dataFluid->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; - state.dataFluid->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); - state.dataFluid->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); - - state.dataFluid->RefrigData(1).PsTemps = DefaultSteamTemps; - state.dataFluid->RefrigData(1).PsValues = DefaultSteamPressData; - state.dataFluid->RefrigData(1).HTemps = DefaultSteamTemps; - state.dataFluid->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; - state.dataFluid->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; - state.dataFluid->RefrigData(1).CpTemps = DefaultSteamTemps; - state.dataFluid->RefrigData(1).CpfValues = DefaultSteamCpFluidData; - state.dataFluid->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; - state.dataFluid->RefrigData(1).RhoTemps = DefaultSteamTemps; - state.dataFluid->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; - state.dataFluid->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; - - state.dataFluid->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; - state.dataFluid->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; - state.dataFluid->RefrigData(1).SHTemps.allocate(state.dataFluid->RefrigData(1).NumSuperTempPts); - state.dataFluid->RefrigData(1).SHPress.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts); - state.dataFluid->RefrigData(1).HshValues.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts, - state.dataFluid->RefrigData(1).NumSuperTempPts); - state.dataFluid->RefrigData(1).RhoshValues.allocate(state.dataFluid->RefrigData(1).NumSuperPressPts, - state.dataFluid->RefrigData(1).NumSuperTempPts); - state.dataFluid->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; - state.dataFluid->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; - state.dataFluid->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; - state.dataFluid->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; + state.dataFluidProperties->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; + state.dataFluidProperties->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).NumHPoints = DefaultNumSteamTemps; + state.dataFluidProperties->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; + state.dataFluidProperties->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; + state.dataFluidProperties->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); + state.dataFluidProperties->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); + + state.dataFluidProperties->RefrigData(1).PsTemps = DefaultSteamTemps; + state.dataFluidProperties->RefrigData(1).PsValues = DefaultSteamPressData; + state.dataFluidProperties->RefrigData(1).HTemps = DefaultSteamTemps; + state.dataFluidProperties->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; + state.dataFluidProperties->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; + state.dataFluidProperties->RefrigData(1).CpTemps = DefaultSteamTemps; + state.dataFluidProperties->RefrigData(1).CpfValues = DefaultSteamCpFluidData; + state.dataFluidProperties->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; + state.dataFluidProperties->RefrigData(1).RhoTemps = DefaultSteamTemps; + state.dataFluidProperties->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; + state.dataFluidProperties->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; + + state.dataFluidProperties->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; + state.dataFluidProperties->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; + state.dataFluidProperties->RefrigData(1).SHTemps.allocate(state.dataFluidProperties->RefrigData(1).NumSuperTempPts); + state.dataFluidProperties->RefrigData(1).SHPress.allocate(state.dataFluidProperties->RefrigData(1).NumSuperPressPts); + state.dataFluidProperties->RefrigData(1).HshValues.allocate(state.dataFluidProperties->RefrigData(1).NumSuperPressPts, + state.dataFluidProperties->RefrigData(1).NumSuperTempPts); + state.dataFluidProperties->RefrigData(1).RhoshValues.allocate(state.dataFluidProperties->RefrigData(1).NumSuperPressPts, + state.dataFluidProperties->RefrigData(1).NumSuperTempPts); + state.dataFluidProperties->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; + state.dataFluidProperties->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; + state.dataFluidProperties->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; + state.dataFluidProperties->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; // Read in all of the temperature arrays in the input file FluidTemps.allocate(NumOfFluidTempArrays); @@ -819,7 +822,7 @@ namespace Fluid { // Go through each refrigerant found in the fluid names statement and read in the data // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. - for (int Loop = 2; Loop <= state.dataFluid->NumOfRefrigerants; ++Loop) { + for (int Loop = 2; Loop <= state.dataFluidProperties->NumOfRefrigerants; ++Loop) { // For each property, cycle through all the valid input until the proper match is found. @@ -844,7 +847,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -853,14 +856,14 @@ namespace Fluid { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->RefrigData(Loop).PsTemps.allocate(state.dataFluid->RefrigData(Loop).NumPsPoints); - state.dataFluid->RefrigData(Loop).PsValues.allocate(state.dataFluid->RefrigData(Loop).NumPsPoints); + state.dataFluidProperties->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->RefrigData(Loop).PsTemps.allocate(state.dataFluidProperties->RefrigData(Loop).NumPsPoints); + state.dataFluidProperties->RefrigData(Loop).PsValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumPsPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumPsPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumPsPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " "same number of points", @@ -868,15 +871,15 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # pressure points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumPsPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumPsPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; - state.dataFluid->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -884,7 +887,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid gas/fluid pressure input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -898,7 +901,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, // then no sat press data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", cAlphaFieldNames(2), @@ -926,7 +929,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -935,14 +938,14 @@ namespace Fluid { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->RefrigData(Loop).HTemps.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); - state.dataFluid->RefrigData(Loop).HfValues.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); + state.dataFluidProperties->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->RefrigData(Loop).HTemps.allocate(state.dataFluidProperties->RefrigData(Loop).NumHPoints); + state.dataFluidProperties->RefrigData(Loop).HfValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumHPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowSevereError(state, format("Temperature Name={}, Temperature array and saturated fluid enthalpy array must have the same " "number of points", @@ -950,15 +953,15 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumHPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; - state.dataFluid->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -966,7 +969,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -979,7 +982,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1006,7 +1009,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1014,7 +1017,7 @@ namespace Fluid { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for enthalpy fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1022,12 +1025,12 @@ namespace Fluid { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).HfgValues.allocate(state.dataFluid->RefrigData(Loop).NumHPoints); + state.dataFluidProperties->RefrigData(Loop).HfgValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumHPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid enthalpy array must have " "the same number of points", @@ -1035,14 +1038,14 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumHPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1050,7 +1053,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1063,7 +1066,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="FluidGas".)", @@ -1092,7 +1095,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1101,14 +1104,14 @@ namespace Fluid { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->RefrigData(Loop).CpTemps.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); - state.dataFluid->RefrigData(Loop).CpfValues.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); + state.dataFluidProperties->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->RefrigData(Loop).CpTemps.allocate(state.dataFluidProperties->RefrigData(Loop).NumCpPoints); + state.dataFluidProperties->RefrigData(Loop).CpfValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowSevereError( state, format("Temperature Name={}, Temperature array and saturated fluid Cp array must have the same number of points", @@ -1116,15 +1119,15 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumCpPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; - state.dataFluid->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1132,7 +1135,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1145,7 +1148,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Fluid Specific Heat found. Need properties to be entered with {}="SpecificHeat" and {}="Fluid".)", @@ -1173,7 +1176,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1181,7 +1184,7 @@ namespace Fluid { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for specific heat fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1189,12 +1192,12 @@ namespace Fluid { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).CpfgValues.allocate(state.dataFluid->RefrigData(Loop).NumCpPoints); + state.dataFluidProperties->RefrigData(Loop).CpfgValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1203,14 +1206,14 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumCpPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1218,7 +1221,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1231,7 +1234,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1261,7 +1264,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1270,14 +1273,14 @@ namespace Fluid { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->RefrigData(Loop).RhoTemps.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); - state.dataFluid->RefrigData(Loop).RhofValues.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); + state.dataFluidProperties->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->RefrigData(Loop).RhoTemps.allocate(state.dataFluidProperties->RefrigData(Loop).NumRhoPoints); + state.dataFluidProperties->RefrigData(Loop).RhofValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated fluid density array must have the " "same number of points", @@ -1285,15 +1288,15 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # Density points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumRhoPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; - state.dataFluid->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1301,7 +1304,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1314,7 +1317,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Density found. Need properties to be entered with {}="Density" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1341,7 +1344,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1349,7 +1352,7 @@ namespace Fluid { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for density fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1357,12 +1360,12 @@ namespace Fluid { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluid->RefrigData(Loop).RhofgValues.allocate(state.dataFluid->RefrigData(Loop).NumRhoPoints); + state.dataFluidProperties->RefrigData(Loop).RhofgValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluid->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != state.dataFluidProperties->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid density array must have the " "same number of points", @@ -1370,14 +1373,14 @@ namespace Fluid { ShowContinueError(state, format("Temperature # points={} whereas {} # density points={}", NumNumbers, - state.dataFluid->RefrigData(Loop).Name, - state.dataFluid->RefrigData(Loop).NumRhoPoints)); + state.dataFluidProperties->RefrigData(Loop).Name, + state.dataFluidProperties->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluid->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); + state.dataFluidProperties->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1385,7 +1388,7 @@ namespace Fluid { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1398,7 +1401,7 @@ namespace Fluid { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowSevereError( state, format(R"(No Saturated Gas/Fluid Density found. Need properties to be entered with {}="Density" and {}="FluidGas".)", @@ -1454,7 +1457,7 @@ namespace Fluid { !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}", "{}".)", Enthalpy, SpecificHeat, Density)); @@ -1469,7 +1472,7 @@ namespace Fluid { !Util::SameString(Alphas(2), SpecificHeat) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, @@ -1481,7 +1484,7 @@ namespace Fluid { } else { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(3), Alphas(3))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Fluid, GasFluid)); ShowContinueError(state, @@ -1518,7 +1521,7 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1526,7 +1529,7 @@ namespace Fluid { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1535,7 +1538,7 @@ namespace Fluid { } } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "No pressure data found for superheated enthalpy"); ErrorsFound = true; } @@ -1544,13 +1547,13 @@ namespace Fluid { // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluid->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->RefrigData(Loop).SHTemps.allocate(state.dataFluid->RefrigData(Loop).NumSuperTempPts); - state.dataFluid->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->RefrigData(Loop).SHTemps.allocate(state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts); + state.dataFluidProperties->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with superheated enthalpy data"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1558,10 +1561,10 @@ namespace Fluid { } // Next, allocate the pressure related arrays - state.dataFluid->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; - state.dataFluid->RefrigData(Loop).SHPress.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts); - state.dataFluid->RefrigData(Loop).HshValues.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts, - state.dataFluid->RefrigData(Loop).NumSuperTempPts); + state.dataFluidProperties->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; + state.dataFluidProperties->RefrigData(Loop).SHPress.allocate(state.dataFluidProperties->RefrigData(Loop).NumSuperPressPts); + state.dataFluidProperties->RefrigData(Loop).HshValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumSuperPressPts, + state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts); // Finally, get the pressure and enthalpy values from the user input CurrentModuleObject = "FluidProperties:Superheated"; @@ -1581,10 +1584,10 @@ namespace Fluid { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1622,27 +1625,27 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - state.dataFluid->RefrigData(Loop).SHPress(InData) = Numbers(1); + state.dataFluidProperties->RefrigData(Loop).SHPress(InData) = Numbers(1); // a little error trapping if (InData > 1) { - if (state.dataFluid->RefrigData(Loop).SHPress(InData) <= state.dataFluid->RefrigData(Loop).SHPress(InData - 1)) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + if (state.dataFluidProperties->RefrigData(Loop).SHPress(InData) <= state.dataFluidProperties->RefrigData(Loop).SHPress(InData - 1)) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Pressures must be entered in ascending order for fluid property data"); ShowContinueError(state, format("First Occurrence at Pressure({}) {{{:.3R}}} >= Pressure({}) {{{:.3R}}}", InData - 1, - state.dataFluid->RefrigData(Loop).SHPress(InData - 1), + state.dataFluidProperties->RefrigData(Loop).SHPress(InData - 1), InData, - state.dataFluid->RefrigData(Loop).SHPress(InData))); + state.dataFluidProperties->RefrigData(Loop).SHPress(InData))); ErrorsFound = true; break; } } - if ((NumNumbers - 1) == state.dataFluid->RefrigData(Loop).NumSuperTempPts) { - state.dataFluid->RefrigData(Loop).HshValues(InData, {1, state.dataFluid->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts) { + state.dataFluidProperties->RefrigData(Loop).HshValues(InData, {1, state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated enthalpy data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1654,8 +1657,8 @@ namespace Fluid { // First find the number of pressure value syntax lines have been entered and // make sure that all of the pressure input is linked to the same temperature list // Then allocate the arrays and read the data into the proper place - state.dataFluid->RefrigData(Loop).RhoshValues.allocate(state.dataFluid->RefrigData(Loop).NumSuperPressPts, - state.dataFluid->RefrigData(Loop).NumSuperTempPts); + state.dataFluidProperties->RefrigData(Loop).RhoshValues.allocate(state.dataFluidProperties->RefrigData(Loop).NumSuperPressPts, + state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts); CurrentModuleObject = "FluidProperties:Superheated"; NumOfPressPts = 0; PressurePtr.allocate(NumOfSHFluidPropArrays); @@ -1672,10 +1675,10 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1713,21 +1716,21 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if (std::abs(Numbers(1) - state.dataFluid->RefrigData(Loop).SHPress(InData)) > PressToler) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + if (std::abs(Numbers(1) - state.dataFluidProperties->RefrigData(Loop).SHPress(InData)) > PressToler) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same refrigerant must use the same pressure data"); ErrorsFound = true; } if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ErrorsFound = true; } - if ((NumNumbers - 1) == state.dataFluid->RefrigData(Loop).NumSuperTempPts) { - state.dataFluid->RefrigData(Loop).RhoshValues(InData, {1, state.dataFluid->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts) { + state.dataFluidProperties->RefrigData(Loop).RhoshValues(InData, {1, state.dataFluidProperties->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1755,7 +1758,7 @@ namespace Fluid { if (!Util::SameString(Alphas(2), Enthalpy) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Enthalpy, Density)); ShowContinueError(state, format("Pressure value of this item=[{:.2R}].", Numbers(1))); @@ -1770,12 +1773,12 @@ namespace Fluid { } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowSevereError(state, "No pressure data found for superheated density"); ErrorsFound = true; } - if (NumOfPressPts != state.dataFluid->RefrigData(Loop).NumSuperPressPts) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->RefrigData(Loop).Name)); + if (NumOfPressPts != state.dataFluidProperties->RefrigData(Loop).NumSuperPressPts) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->RefrigData(Loop).Name)); ShowSevereError(state, "Number of pressure points for superheated data different for enthalpy and density"); ErrorsFound = true; } @@ -1787,7 +1790,7 @@ namespace Fluid { // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. CurrentModuleObject = "FluidProperties:Concentration"; - for (int Loop = 1; Loop <= state.dataFluid->NumOfGlycols; ++Loop) { + for (int Loop = 1; Loop <= state.dataFluidProperties->NumOfGlycols; ++Loop) { // Get: ***** SPECIFIC HEAT of GLYCOLS ***** // First find the number of concentration value syntax lines have been entered and @@ -1795,7 +1798,7 @@ namespace Fluid { TempsName = ""; FirstSHMatch = true; int NumOfConcPts = 0; - state.dataFluid->GlyRawData(Loop).CpDataPresent = false; + state.dataFluidProperties->GlyRawData(Loop).CpDataPresent = false; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, @@ -1809,7 +1812,7 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1817,7 +1820,7 @@ namespace Fluid { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol specific heat data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1828,26 +1831,26 @@ namespace Fluid { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluid->GlyRawData(Loop).CpDataPresent = true; + state.dataFluidProperties->GlyRawData(Loop).CpDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluid->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->GlyRawData(Loop).CpTemps.allocate(state.dataFluid->GlyRawData(Loop).NumCpTempPts); - state.dataFluid->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->GlyRawData(Loop).CpTemps.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCpTempPts); + state.dataFluidProperties->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the specific heat related arrays - state.dataFluid->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; - state.dataFluid->GlyRawData(Loop).CpConcs.allocate(state.dataFluid->GlyRawData(Loop).NumCpConcPts); - state.dataFluid->GlyRawData(Loop).CpValues.allocate(state.dataFluid->GlyRawData(Loop).NumCpConcPts, - state.dataFluid->GlyRawData(Loop).NumCpTempPts); + state.dataFluidProperties->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; + state.dataFluidProperties->GlyRawData(Loop).CpConcs.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCpConcPts); + state.dataFluidProperties->GlyRawData(Loop).CpValues.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCpConcPts, + state.dataFluidProperties->GlyRawData(Loop).NumCpTempPts); // Finally, get the specific heat and concentration values from the user input CurrentModuleObject = "FluidProperties:Concentration"; @@ -1865,32 +1868,32 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; - state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); + state.dataFluidProperties->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { + if (state.dataFluidProperties->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts) <= - state.dataFluid->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { + if (state.dataFluidProperties->GlyRawData(Loop).CpConcs(NumOfConcPts) <= + state.dataFluidProperties->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumCpTempPts) { - state.dataFluid->GlyRawData(Loop).CpValues(NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumCpTempPts}) = + if ((NumNumbers - 1) == state.dataFluidProperties->GlyRawData(Loop).NumCpTempPts) { + state.dataFluidProperties->GlyRawData(Loop).CpValues(NumOfConcPts, {1, state.dataFluidProperties->GlyRawData(Loop).NumCpTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of specific heat data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1903,7 +1906,7 @@ namespace Fluid { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluid->GlyRawData(Loop).RhoDataPresent = false; + state.dataFluidProperties->GlyRawData(Loop).RhoDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for density are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1918,7 +1921,7 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1926,7 +1929,7 @@ namespace Fluid { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol density data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1937,26 +1940,26 @@ namespace Fluid { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluid->GlyRawData(Loop).RhoDataPresent = true; + state.dataFluidProperties->GlyRawData(Loop).RhoDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluid->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->GlyRawData(Loop).RhoTemps.allocate(state.dataFluid->GlyRawData(Loop).NumRhoTempPts); - state.dataFluid->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->GlyRawData(Loop).RhoTemps.allocate(state.dataFluidProperties->GlyRawData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the density related arrays - state.dataFluid->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; - state.dataFluid->GlyRawData(Loop).RhoConcs.allocate(state.dataFluid->GlyRawData(Loop).NumRhoConcPts); - state.dataFluid->GlyRawData(Loop).RhoValues.allocate(state.dataFluid->GlyRawData(Loop).NumRhoConcPts, - state.dataFluid->GlyRawData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; + state.dataFluidProperties->GlyRawData(Loop).RhoConcs.allocate(state.dataFluidProperties->GlyRawData(Loop).NumRhoConcPts); + state.dataFluidProperties->GlyRawData(Loop).RhoValues.allocate(state.dataFluidProperties->GlyRawData(Loop).NumRhoConcPts, + state.dataFluidProperties->GlyRawData(Loop).NumRhoTempPts); // Finally, get the density and concentration values from the user input NumOfConcPts = 0; @@ -1974,32 +1977,32 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; - state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); + state.dataFluidProperties->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { + if (state.dataFluidProperties->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= - state.dataFluid->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { + if (state.dataFluidProperties->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= + state.dataFluidProperties->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumRhoTempPts) { - state.dataFluid->GlyRawData(Loop).RhoValues( - NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluidProperties->GlyRawData(Loop).NumRhoTempPts) { + state.dataFluidProperties->GlyRawData(Loop).RhoValues( + NumOfConcPts, {1, state.dataFluidProperties->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2012,7 +2015,7 @@ namespace Fluid { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluid->GlyRawData(Loop).CondDataPresent = false; + state.dataFluidProperties->GlyRawData(Loop).CondDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for conductivity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2027,7 +2030,7 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2035,7 +2038,7 @@ namespace Fluid { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol conductivity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2046,26 +2049,26 @@ namespace Fluid { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluid->GlyRawData(Loop).CondDataPresent = true; + state.dataFluidProperties->GlyRawData(Loop).CondDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluid->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->GlyRawData(Loop).CondTemps.allocate(state.dataFluid->GlyRawData(Loop).NumCondTempPts); - state.dataFluid->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->GlyRawData(Loop).CondTemps.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCondTempPts); + state.dataFluidProperties->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the conductivity related arrays - state.dataFluid->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; - state.dataFluid->GlyRawData(Loop).CondConcs.allocate(state.dataFluid->GlyRawData(Loop).NumCondConcPts); - state.dataFluid->GlyRawData(Loop).CondValues.allocate(state.dataFluid->GlyRawData(Loop).NumCondConcPts, - state.dataFluid->GlyRawData(Loop).NumCondTempPts); + state.dataFluidProperties->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; + state.dataFluidProperties->GlyRawData(Loop).CondConcs.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCondConcPts); + state.dataFluidProperties->GlyRawData(Loop).CondValues.allocate(state.dataFluidProperties->GlyRawData(Loop).NumCondConcPts, + state.dataFluidProperties->GlyRawData(Loop).NumCondTempPts); // Finally, get the conductivity and concentration values from the user input NumOfConcPts = 0; @@ -2083,32 +2086,32 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; - state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); + state.dataFluidProperties->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { + if (state.dataFluidProperties->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts) <= - state.dataFluid->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { + if (state.dataFluidProperties->GlyRawData(Loop).CondConcs(NumOfConcPts) <= + state.dataFluidProperties->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumCondTempPts) { - state.dataFluid->GlyRawData(Loop).CondValues( - NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluidProperties->GlyRawData(Loop).NumCondTempPts) { + state.dataFluidProperties->GlyRawData(Loop).CondValues( + NumOfConcPts, {1, state.dataFluidProperties->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of conductivity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2121,7 +2124,7 @@ namespace Fluid { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluid->GlyRawData(Loop).ViscDataPresent = false; + state.dataFluidProperties->GlyRawData(Loop).ViscDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for viscosity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2136,7 +2139,7 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2144,7 +2147,7 @@ namespace Fluid { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol viscosity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2153,28 +2156,28 @@ namespace Fluid { } } if (NumOfConcPts > 0) { - state.dataFluid->GlyRawData(Loop).ViscDataPresent = true; + state.dataFluidProperties->GlyRawData(Loop).ViscDataPresent = true; // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluid->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluid->GlyRawData(Loop).ViscTemps.allocate(state.dataFluid->GlyRawData(Loop).NumViscTempPts); - state.dataFluid->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; + state.dataFluidProperties->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; + state.dataFluidProperties->GlyRawData(Loop).ViscTemps.allocate(state.dataFluidProperties->GlyRawData(Loop).NumViscTempPts); + state.dataFluidProperties->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the viscosity related arrays - state.dataFluid->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; - state.dataFluid->GlyRawData(Loop).ViscConcs.allocate(state.dataFluid->GlyRawData(Loop).NumViscConcPts); - state.dataFluid->GlyRawData(Loop).ViscValues.allocate(state.dataFluid->GlyRawData(Loop).NumViscConcPts, - state.dataFluid->GlyRawData(Loop).NumViscTempPts); + state.dataFluidProperties->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; + state.dataFluidProperties->GlyRawData(Loop).ViscConcs.allocate(state.dataFluidProperties->GlyRawData(Loop).NumViscConcPts); + state.dataFluidProperties->GlyRawData(Loop).ViscValues.allocate(state.dataFluidProperties->GlyRawData(Loop).NumViscConcPts, + state.dataFluidProperties->GlyRawData(Loop).NumViscTempPts); // Finally, get the viscosity and concentration values from the user input NumOfConcPts = 0; @@ -2192,32 +2195,32 @@ namespace Fluid { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluid->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), state.dataFluidProperties->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; - state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); + state.dataFluidProperties->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { + if (state.dataFluidProperties->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= - state.dataFluid->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { + if (state.dataFluidProperties->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= + state.dataFluidProperties->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluid->GlyRawData(Loop).NumViscTempPts) { - state.dataFluid->GlyRawData(Loop).ViscValues( - NumOfConcPts, {1, state.dataFluid->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == state.dataFluidProperties->GlyRawData(Loop).NumViscTempPts) { + state.dataFluidProperties->GlyRawData(Loop).ViscValues( + NumOfConcPts, {1, state.dataFluidProperties->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluid->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProperties->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of viscosity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2258,40 +2261,40 @@ namespace Fluid { NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); int NumOfGlyConcs = NumOfOptionalInput + 1; - state.dataFluid->GlycolData.allocate(NumOfGlyConcs); - state.dataFluid->GlycolUsed.dimension(NumOfGlyConcs, false); + state.dataFluidProperties->GlycolData.allocate(NumOfGlyConcs); + state.dataFluidProperties->GlycolUsed.dimension(NumOfGlyConcs, false); - state.dataFluid->GlycolUsed(1) = true; // mark Water as always used + state.dataFluidProperties->GlycolUsed(1) = true; // mark Water as always used // First "glycol" is always pure water. Load data from default arrays - state.dataFluid->GlycolData(1).Name = "WATER"; - state.dataFluid->GlycolData(1).GlycolName = "WATER"; - state.dataFluid->GlycolData(1).GlycolIndex = 0; - state.dataFluid->GlycolData(1).Concentration = 1.0; - state.dataFluid->GlycolData(1).CpDataPresent = true; - state.dataFluid->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(1).RhoDataPresent = true; - state.dataFluid->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(1).CondDataPresent = true; - state.dataFluid->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(1).ViscDataPresent = true; - state.dataFluid->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(1).CpTemps.allocate(state.dataFluid->GlycolData(1).NumCpTempPts); - state.dataFluid->GlycolData(1).CpValues.allocate(state.dataFluid->GlycolData(1).NumCpTempPts); - state.dataFluid->GlycolData(1).RhoTemps.allocate(state.dataFluid->GlycolData(1).NumRhoTempPts); - state.dataFluid->GlycolData(1).RhoValues.allocate(state.dataFluid->GlycolData(1).NumRhoTempPts); - state.dataFluid->GlycolData(1).CondTemps.allocate(state.dataFluid->GlycolData(1).NumCondTempPts); - state.dataFluid->GlycolData(1).CondValues.allocate(state.dataFluid->GlycolData(1).NumCondTempPts); - state.dataFluid->GlycolData(1).ViscTemps.allocate(state.dataFluid->GlycolData(1).NumViscTempPts); - state.dataFluid->GlycolData(1).ViscValues.allocate(state.dataFluid->GlycolData(1).NumViscTempPts); - state.dataFluid->GlycolData(1).CpTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(1).CpValues = DefaultWaterCpData; - state.dataFluid->GlycolData(1).RhoTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(1).RhoValues = DefaultWaterRhoData; - state.dataFluid->GlycolData(1).CondTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(1).CondValues = DefaultWaterCondData; - state.dataFluid->GlycolData(1).ViscTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(1).ViscValues = DefaultWaterViscData; + state.dataFluidProperties->GlycolData(1).Name = "WATER"; + state.dataFluidProperties->GlycolData(1).GlycolName = "WATER"; + state.dataFluidProperties->GlycolData(1).Num = 1; + state.dataFluidProperties->GlycolData(1).Concentration = 1.0; + state.dataFluidProperties->GlycolData(1).CpDataPresent = true; + state.dataFluidProperties->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(1).RhoDataPresent = true; + state.dataFluidProperties->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(1).CondDataPresent = true; + state.dataFluidProperties->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(1).ViscDataPresent = true; + state.dataFluidProperties->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(1).CpTemps.allocate(state.dataFluidProperties->GlycolData(1).NumCpTempPts); + state.dataFluidProperties->GlycolData(1).CpValues.allocate(state.dataFluidProperties->GlycolData(1).NumCpTempPts); + state.dataFluidProperties->GlycolData(1).RhoTemps.allocate(state.dataFluidProperties->GlycolData(1).NumRhoTempPts); + state.dataFluidProperties->GlycolData(1).RhoValues.allocate(state.dataFluidProperties->GlycolData(1).NumRhoTempPts); + state.dataFluidProperties->GlycolData(1).CondTemps.allocate(state.dataFluidProperties->GlycolData(1).NumCondTempPts); + state.dataFluidProperties->GlycolData(1).CondValues.allocate(state.dataFluidProperties->GlycolData(1).NumCondTempPts); + state.dataFluidProperties->GlycolData(1).ViscTemps.allocate(state.dataFluidProperties->GlycolData(1).NumViscTempPts); + state.dataFluidProperties->GlycolData(1).ViscValues.allocate(state.dataFluidProperties->GlycolData(1).NumViscTempPts); + state.dataFluidProperties->GlycolData(1).CpTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(1).CpValues = DefaultWaterCpData; + state.dataFluidProperties->GlycolData(1).RhoTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(1).RhoValues = DefaultWaterRhoData; + state.dataFluidProperties->GlycolData(1).CondTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(1).CondValues = DefaultWaterCondData; + state.dataFluidProperties->GlycolData(1).ViscTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(1).ViscValues = DefaultWaterViscData; NumOfGlyConcs = 1; // Water is always available, everything else must be specified @@ -2312,24 +2315,28 @@ namespace Fluid { if (Util::SameString(Alphas(2), EthyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + + state.dataFluidProperties->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), PropyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + state.dataFluidProperties->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), "UserDefinedGlycolType")) { - for (InData = 1; InData <= state.dataFluid->NumOfGlycols; ++InData) { - if (Util::SameString(Alphas(3), state.dataFluid->GlyRawData(InData).Name)) { + for (InData = 1; InData <= state.dataFluidProperties->NumOfGlycols; ++InData) { + if (Util::SameString(Alphas(3), state.dataFluidProperties->GlyRawData(InData).Name)) { GlycolFound = true; break; // DO LOOP through user defined glycols } } if (GlycolFound) { ++NumOfGlyConcs; - state.dataFluid->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluid->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Name = Alphas(1); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + state.dataFluidProperties->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); } else { ShowSevereError(state, format("{}{}=\"{}\", invalid reference", RoutineName, CurrentModuleObject, Alphas(1))); ShowContinueError(state, format("... not found in the FluidProperties:Name list: \"{}\".", Alphas(3))); @@ -2342,192 +2349,192 @@ namespace Fluid { ErrorsFound = true; } if (!GlycolFound) continue; - state.dataFluid->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); + state.dataFluidProperties->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); } // Now initialize the rest of the data for the glycols for (int Loop = 2; Loop <= NumOfGlyConcs; ++Loop) { // Check to see if glycol name is one of the defaults or is listed in the Fluid Name list - if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, EthyleneGlycol)) { - state.dataFluid->GlycolData(Loop).GlycolIndex = EthyleneGlycolIndex; - } else if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, PropyleneGlycol)) { - state.dataFluid->GlycolData(Loop).GlycolIndex = PropyleneGlycolIndex; + if (Util::SameString(state.dataFluidProperties->GlycolData(Loop).GlycolName, EthyleneGlycol)) { + state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex = EthyleneGlycolIndex; + } else if (Util::SameString(state.dataFluidProperties->GlycolData(Loop).GlycolName, PropyleneGlycol)) { + state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex = PropyleneGlycolIndex; } else { - for (InData = 1; InData <= state.dataFluid->NumOfGlycols; ++InData) { - if (Util::SameString(state.dataFluid->GlycolData(Loop).GlycolName, state.dataFluid->GlyRawData(InData).Name)) { - state.dataFluid->GlycolData(Loop).GlycolIndex = InData; + for (InData = 1; InData <= state.dataFluidProperties->NumOfGlycols; ++InData) { + if (Util::SameString(state.dataFluidProperties->GlycolData(Loop).GlycolName, state.dataFluidProperties->GlyRawData(InData).Name)) { + state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex = InData; break; // DO LOOP through user defined glycols } } } // Set the rest of the parameters... - if ((state.dataFluid->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) || - (state.dataFluid->GlycolData(Loop).GlycolIndex == PropyleneGlycolIndex)) { - - state.dataFluid->GlycolData(Loop).CpDataPresent = true; - state.dataFluid->GlycolData(Loop).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(Loop).RhoDataPresent = true; - state.dataFluid->GlycolData(Loop).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(Loop).CondDataPresent = true; - state.dataFluid->GlycolData(Loop).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(Loop).ViscDataPresent = true; - state.dataFluid->GlycolData(Loop).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluid->GlycolData(Loop).CpTemps.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); - state.dataFluid->GlycolData(Loop).CpValues.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); - state.dataFluid->GlycolData(Loop).RhoTemps.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); - state.dataFluid->GlycolData(Loop).RhoValues.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); - state.dataFluid->GlycolData(Loop).CondTemps.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); - state.dataFluid->GlycolData(Loop).CondValues.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); - state.dataFluid->GlycolData(Loop).ViscTemps.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); - state.dataFluid->GlycolData(Loop).ViscValues.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); - state.dataFluid->GlycolData(Loop).CpTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(Loop).RhoTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(Loop).CondTemps = DefaultGlycolTemps; - state.dataFluid->GlycolData(Loop).ViscTemps = DefaultGlycolTemps; - - if (state.dataFluid->GlycolData(Loop).GlycolIndex == EthyleneGlycolIndex) { + if ((state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex == EthyleneGlycolIndex) || + (state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex == PropyleneGlycolIndex)) { + + state.dataFluidProperties->GlycolData(Loop).CpDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumCpTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(Loop).RhoDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(Loop).CondDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumCondTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(Loop).ViscDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumViscTempPts = DefaultNumGlyTemps; + state.dataFluidProperties->GlycolData(Loop).CpTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumCpTempPts); + state.dataFluidProperties->GlycolData(Loop).CpValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumCpTempPts); + state.dataFluidProperties->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlycolData(Loop).RhoValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlycolData(Loop).CondTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumCondTempPts); + state.dataFluidProperties->GlycolData(Loop).CondValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumCondTempPts); + state.dataFluidProperties->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumViscTempPts); + state.dataFluidProperties->GlycolData(Loop).ViscValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumViscTempPts); + state.dataFluidProperties->GlycolData(Loop).CpTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(Loop).RhoTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(Loop).CondTemps = DefaultGlycolTemps; + state.dataFluidProperties->GlycolData(Loop).ViscTemps = DefaultGlycolTemps; + + if (state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex == EthyleneGlycolIndex) { InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCpData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CpValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CpValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyRhoData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).RhoValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCondData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CondValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyViscData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).ViscValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).ViscValues); } else { // == PropyleneGlycolIndex InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCpData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CpValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CpValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyRhoData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).RhoValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCondData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CondValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyViscData, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).ViscValues); + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).ViscValues); } } else { // User-defined fluid - int Index = state.dataFluid->GlycolData(Loop).GlycolIndex; + int Index = state.dataFluidProperties->GlycolData(Loop).BaseGlycolIndex; // Specific heat data: - if (state.dataFluid->GlyRawData(Index).CpDataPresent) { - state.dataFluid->GlycolData(Loop).CpDataPresent = true; - state.dataFluid->GlycolData(Loop).NumCpTempPts = state.dataFluid->GlyRawData(Index).NumCpTempPts; - state.dataFluid->GlycolData(Loop).CpTemps.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); - state.dataFluid->GlycolData(Loop).CpValues.allocate(state.dataFluid->GlycolData(Loop).NumCpTempPts); - state.dataFluid->GlycolData(Loop).CpTemps = state.dataFluid->GlyRawData(Index).CpTemps; + if (state.dataFluidProperties->GlyRawData(Index).CpDataPresent) { + state.dataFluidProperties->GlycolData(Loop).CpDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumCpTempPts = state.dataFluidProperties->GlyRawData(Index).NumCpTempPts; + state.dataFluidProperties->GlycolData(Loop).CpTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumCpTempPts); + state.dataFluidProperties->GlycolData(Loop).CpValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumCpTempPts); + state.dataFluidProperties->GlycolData(Loop).CpTemps = state.dataFluidProperties->GlyRawData(Index).CpTemps; InterpValuesForGlycolConc(state, - state.dataFluid->GlyRawData(Index).NumCpConcPts, - state.dataFluid->GlyRawData(Index).NumCpTempPts, - state.dataFluid->GlyRawData(Index).CpConcs, - state.dataFluid->GlyRawData(Index).CpValues, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CpValues); + state.dataFluidProperties->GlyRawData(Index).NumCpConcPts, + state.dataFluidProperties->GlyRawData(Index).NumCpTempPts, + state.dataFluidProperties->GlyRawData(Index).CpConcs, + state.dataFluidProperties->GlyRawData(Index).CpValues, + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CpValues); } else { ShowSevereError(state, format("{}Specific heat data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProperties->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProperties->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Density data: - if (state.dataFluid->GlyRawData(Index).CpDataPresent) { - state.dataFluid->GlycolData(Loop).RhoDataPresent = true; - state.dataFluid->GlycolData(Loop).NumRhoTempPts = state.dataFluid->GlyRawData(Index).NumRhoTempPts; - state.dataFluid->GlycolData(Loop).RhoTemps.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); - state.dataFluid->GlycolData(Loop).RhoValues.allocate(state.dataFluid->GlycolData(Loop).NumRhoTempPts); - state.dataFluid->GlycolData(Loop).RhoTemps = state.dataFluid->GlyRawData(Index).RhoTemps; + if (state.dataFluidProperties->GlyRawData(Index).CpDataPresent) { + state.dataFluidProperties->GlycolData(Loop).RhoDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts = state.dataFluidProperties->GlyRawData(Index).NumRhoTempPts; + state.dataFluidProperties->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlycolData(Loop).RhoValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumRhoTempPts); + state.dataFluidProperties->GlycolData(Loop).RhoTemps = state.dataFluidProperties->GlyRawData(Index).RhoTemps; InterpValuesForGlycolConc(state, - state.dataFluid->GlyRawData(Index).NumRhoConcPts, - state.dataFluid->GlyRawData(Index).NumRhoTempPts, - state.dataFluid->GlyRawData(Index).RhoConcs, - state.dataFluid->GlyRawData(Index).RhoValues, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).RhoValues); + state.dataFluidProperties->GlyRawData(Index).NumRhoConcPts, + state.dataFluidProperties->GlyRawData(Index).NumRhoTempPts, + state.dataFluidProperties->GlyRawData(Index).RhoConcs, + state.dataFluidProperties->GlyRawData(Index).RhoValues, + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).RhoValues); } else { ShowSevereError(state, format("{}Density data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProperties->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProperties->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Conductivity data: - if (state.dataFluid->GlyRawData(Index).CondDataPresent) { - state.dataFluid->GlycolData(Loop).CondDataPresent = true; - state.dataFluid->GlycolData(Loop).NumCondTempPts = state.dataFluid->GlyRawData(Index).NumCondTempPts; - state.dataFluid->GlycolData(Loop).CondTemps.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); - state.dataFluid->GlycolData(Loop).CondValues.allocate(state.dataFluid->GlycolData(Loop).NumCondTempPts); - state.dataFluid->GlycolData(Loop).CondTemps = state.dataFluid->GlyRawData(Index).CondTemps; + if (state.dataFluidProperties->GlyRawData(Index).CondDataPresent) { + state.dataFluidProperties->GlycolData(Loop).CondDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumCondTempPts = state.dataFluidProperties->GlyRawData(Index).NumCondTempPts; + state.dataFluidProperties->GlycolData(Loop).CondTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumCondTempPts); + state.dataFluidProperties->GlycolData(Loop).CondValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumCondTempPts); + state.dataFluidProperties->GlycolData(Loop).CondTemps = state.dataFluidProperties->GlyRawData(Index).CondTemps; InterpValuesForGlycolConc(state, - state.dataFluid->GlyRawData(Index).NumCondConcPts, - state.dataFluid->GlyRawData(Index).NumCondTempPts, - state.dataFluid->GlyRawData(Index).CondConcs, - state.dataFluid->GlyRawData(Index).CondValues, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).CondValues); + state.dataFluidProperties->GlyRawData(Index).NumCondConcPts, + state.dataFluidProperties->GlyRawData(Index).NumCondTempPts, + state.dataFluidProperties->GlyRawData(Index).CondConcs, + state.dataFluidProperties->GlyRawData(Index).CondValues, + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).CondValues); } else { ShowSevereError(state, format("{}Conductivity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProperties->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProperties->GlycolData(Loop).GlycolName)); ErrorsFound = true; } // Viscosity data: - if (state.dataFluid->GlyRawData(Index).ViscDataPresent) { - state.dataFluid->GlycolData(Loop).ViscDataPresent = true; - state.dataFluid->GlycolData(Loop).NumViscTempPts = state.dataFluid->GlyRawData(Index).NumViscTempPts; - state.dataFluid->GlycolData(Loop).ViscTemps.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); - state.dataFluid->GlycolData(Loop).ViscValues.allocate(state.dataFluid->GlycolData(Loop).NumViscTempPts); - state.dataFluid->GlycolData(Loop).ViscTemps = state.dataFluid->GlyRawData(Index).ViscTemps; + if (state.dataFluidProperties->GlyRawData(Index).ViscDataPresent) { + state.dataFluidProperties->GlycolData(Loop).ViscDataPresent = true; + state.dataFluidProperties->GlycolData(Loop).NumViscTempPts = state.dataFluidProperties->GlyRawData(Index).NumViscTempPts; + state.dataFluidProperties->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProperties->GlycolData(Loop).NumViscTempPts); + state.dataFluidProperties->GlycolData(Loop).ViscValues.allocate(state.dataFluidProperties->GlycolData(Loop).NumViscTempPts); + state.dataFluidProperties->GlycolData(Loop).ViscTemps = state.dataFluidProperties->GlyRawData(Index).ViscTemps; InterpValuesForGlycolConc(state, - state.dataFluid->GlyRawData(Index).NumViscConcPts, - state.dataFluid->GlyRawData(Index).NumViscTempPts, - state.dataFluid->GlyRawData(Index).ViscConcs, - state.dataFluid->GlyRawData(Index).ViscValues, - state.dataFluid->GlycolData(Loop).Concentration, - state.dataFluid->GlycolData(Loop).ViscValues); + state.dataFluidProperties->GlyRawData(Index).NumViscConcPts, + state.dataFluidProperties->GlyRawData(Index).NumViscTempPts, + state.dataFluidProperties->GlyRawData(Index).ViscConcs, + state.dataFluidProperties->GlyRawData(Index).ViscValues, + state.dataFluidProperties->GlycolData(Loop).Concentration, + state.dataFluidProperties->GlycolData(Loop).ViscValues); } else { ShowSevereError(state, format("{}Viscosity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluid->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluid->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProperties->GlycolData(Loop).Name)); + ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProperties->GlycolData(Loop).GlycolName)); ErrorsFound = true; } } } - state.dataFluid->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number - state.dataFluid->GlycolErrorTracking.allocate(state.dataFluid->NumOfGlycols); - for (std::size_t i = 0; i < state.dataFluid->GlycolErrorTracking.size(); ++i) - state.dataFluid->GlycolErrorTracking[i].Name = state.dataFluid->GlycolData[i].Name; + state.dataFluidProperties->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number + state.dataFluidProperties->GlycolErrorTracking.allocate(state.dataFluidProperties->NumOfGlycols); + for (std::size_t i = 0; i < state.dataFluidProperties->GlycolErrorTracking.size(); ++i) + state.dataFluidProperties->GlycolErrorTracking[i].Name = state.dataFluidProperties->GlycolData[i].Name; if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols @@ -2546,16 +2553,16 @@ namespace Fluid { ShowFatalError(state, format("{}Previous errors in input cause program termination.", RoutineName)); } - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) state.dataFluid->DebugReportGlycols = true; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) state.dataFluidProperties->DebugReportGlycols = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTREFRIGERANTS") > 0) - state.dataFluid->DebugReportRefrigerants = true; + state.dataFluidProperties->DebugReportRefrigerants = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEGLYCOLERRORLIMIT") > 0) - state.dataFluid->GlycolErrorLimitTest += 10; + state.dataFluidProperties->GlycolErrorLimitTest += 10; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEREFRIGERANTERRORLIMIT") > 0) - state.dataFluid->RefrigerantErrorLimitTest += 10; + state.dataFluidProperties->RefrigerantErrorLimitTest += 10; - if (state.dataFluid->DebugReportGlycols) ReportAndTestGlycols(state); - if (state.dataFluid->DebugReportRefrigerants) ReportAndTestRefrigerants(state); + if (state.dataFluidProperties->DebugReportGlycols) ReportAndTestGlycols(state); + if (state.dataFluidProperties->DebugReportRefrigerants) ReportAndTestRefrigerants(state); } [[maybe_unused]] static constexpr std::array, DefaultNumSteamSuperheatedPressure> @@ -4683,8 +4690,8 @@ namespace Fluid { // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. - for (int GlycolNum = 1; GlycolNum <= state.dataFluid->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluid->GlycolData(GlycolNum); + for (int GlycolNum = 1; GlycolNum <= state.dataFluidProperties->NumOfGlycols; ++GlycolNum) { + auto &glycol = state.dataFluidProperties->GlycolData(GlycolNum); if (glycol.CpDataPresent) { // check for lowest non-zero value by referencing temp data for (int IndexNum = 1; IndexNum <= glycol.NumCpTempPts; ++IndexNum) { @@ -4786,8 +4793,8 @@ namespace Fluid { // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. - for (int RefrigNum = 1; RefrigNum <= state.dataFluid->NumOfRefrigerants; ++RefrigNum) { - auto &refrig = state.dataFluid->RefrigData(RefrigNum); + for (int RefrigNum = 1; RefrigNum <= state.dataFluidProperties->NumOfRefrigerants; ++RefrigNum) { + auto &refrig = state.dataFluidProperties->RefrigData(RefrigNum); for (int IndexNum = 1; IndexNum <= refrig.NumPsPoints; ++IndexNum) { if (refrig.PsValues(IndexNum) <= 0.0) continue; refrig.PsLowPresIndex = IndexNum; @@ -4926,10 +4933,10 @@ namespace Fluid { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from glycol functions - state.dataFluid->GetInput = false; // input has already been gotten + state.dataFluidProperties->GetInput = false; // input has already been gotten - for (int GlycolNum = 1; GlycolNum <= state.dataFluid->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluid->GlycolData(GlycolNum); + for (int GlycolNum = 1; GlycolNum <= state.dataFluidProperties->NumOfGlycols; ++GlycolNum) { + auto &glycol = state.dataFluidProperties->GlycolData(GlycolNum); int GlycolIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: if (!glycol.GlycolName.empty()) { @@ -5168,223 +5175,223 @@ namespace Fluid { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from refrigerant functions - state.dataFluid->GetInput = false; // input has already been gotten + state.dataFluidProperties->GetInput = false; // input has already been gotten - for (int RefrigNum = 1; RefrigNum <= state.dataFluid->NumOfRefrigerants; ++RefrigNum) { + for (int RefrigNum = 1; RefrigNum <= state.dataFluidProperties->NumOfRefrigerants; ++RefrigNum) { int RefrigIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: - if (!state.dataFluid->RefrigData(RefrigNum).Name.empty()) { - print(state.files.debug, "Refrigerant={}", state.dataFluid->RefrigData(RefrigNum).Name); + if (!state.dataFluidProperties->RefrigData(RefrigNum).Name.empty()) { + print(state.files.debug, "Refrigerant={}", state.dataFluidProperties->RefrigData(RefrigNum).Name); } - if (state.dataFluid->RefrigData(RefrigNum).NumPsPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints > 0) { print(state.files.debug, "Saturation Pressures Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).PsLowTempValue, - state.dataFluid->RefrigData(RefrigNum).PsLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).PsHighTempValue, - state.dataFluid->RefrigData(RefrigNum).PsHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).PsLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).PsLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).PsHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).PsHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints)); print(state.files.debug, "Saturation Pressure:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).PsValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).PsValues(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).PsValues(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints)); } - if (state.dataFluid->RefrigData(RefrigNum).NumHPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints > 0) { print(state.files.debug, "Enthalpy Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).HfLowTempValue, - state.dataFluid->RefrigData(RefrigNum).HfLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).HfHighTempValue, - state.dataFluid->RefrigData(RefrigNum).HfHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).HfLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).HfLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).HfHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).HfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HfValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HfValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).HfValues(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).HfValues(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).HfgLowTempValue, - state.dataFluid->RefrigData(RefrigNum).HfgLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).HfgHighTempValue, - state.dataFluid->RefrigData(RefrigNum).HfgHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).HfgLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).HfgLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).HfgHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).HfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HfgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HfgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).HfgValues(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).HfgValues(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints)); } - if (state.dataFluid->RefrigData(RefrigNum).NumCpPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints > 0) { print(state.files.debug, "Specific Heat Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).CpfLowTempValue, - state.dataFluid->RefrigData(RefrigNum).CpfLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).CpfHighTempValue, - state.dataFluid->RefrigData(RefrigNum).CpfHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).CpfLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).CpfLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).CpfHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).CpfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}\n", state.dataFluid->RefrigData(RefrigNum).CpfValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}\n", state.dataFluidProperties->RefrigData(RefrigNum).CpfValues(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).CpfValues(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).CpfValues(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).CpfgLowTempValue, - state.dataFluid->RefrigData(RefrigNum).CpfgLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).CpfgHighTempValue, - state.dataFluid->RefrigData(RefrigNum).CpfgHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).CpfgLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).CpfgLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).CpfgHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).CpfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpfgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).CpfgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).CpfgValues(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).CpfgValues(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints)); } - if (state.dataFluid->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints > 0) { print(state.files.debug, "Density Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).RhofLowTempValue, - state.dataFluid->RefrigData(RefrigNum).RhofLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).RhofHighTempValue, - state.dataFluid->RefrigData(RefrigNum).RhofHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).RhofLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).RhofLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).RhofHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).RhofHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhofValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhofValues(Loop)); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).RhofValues(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).RhofValues(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluid->RefrigData(RefrigNum).RhofgLowTempValue, - state.dataFluid->RefrigData(RefrigNum).RhofgLowTempIndex, - state.dataFluid->RefrigData(RefrigNum).RhofgHighTempValue, - state.dataFluid->RefrigData(RefrigNum).RhofgHighTempIndex); + state.dataFluidProperties->RefrigData(RefrigNum).RhofgLowTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).RhofgLowTempIndex, + state.dataFluidProperties->RefrigData(RefrigNum).RhofgHighTempValue, + state.dataFluidProperties->RefrigData(RefrigNum).RhofgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhofgValues(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhofgValues(Loop)); } print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).RhofgValues(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).RhofgValues(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints)); } - if (state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts > 0 && state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts > 0 && state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts > 0) { print(state.files.debug, "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", - state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts, - state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts); + state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts, + state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts); print(state.files.debug, "Superheated Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).SHTemps(Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).SHTemps(state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluidProperties->RefrigData(RefrigNum).SHTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts)); print(state.files.debug, "Superheated Pressures:"); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).SHPress(Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).SHPress(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts)); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); + state.dataFluidProperties->RefrigData(RefrigNum).SHPress(state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProperties->RefrigData(RefrigNum).SHPress(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).HshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).HshValues(Loop, Loop1)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).HshValues(Loop, state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluidProperties->RefrigData(RefrigNum).HshValues(Loop, state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProperties->RefrigData(RefrigNum).SHPress(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoshValues(Loop, Loop1)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop, state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts)); + state.dataFluidProperties->RefrigData(RefrigNum).RhoshValues(Loop, state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProperties->RefrigData(RefrigNum).SHTemps(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).HshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).HshValues(Loop1, Loop)); } print(state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).HshValues(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + state.dataFluidProperties->RefrigData(RefrigNum).HshValues(state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts, Loop)); } - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluid->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProperties->RefrigData(RefrigNum).SHTemps(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluid->RefrigData(RefrigNum).RhoshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoshValues(Loop1, Loop)); } print( state.files.debug, ",{:.3R}\n", - state.dataFluid->RefrigData(RefrigNum).RhoshValues(state.dataFluid->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + state.dataFluidProperties->RefrigData(RefrigNum).RhoshValues(state.dataFluidProperties->RefrigData(RefrigNum).NumSuperPressPts, Loop)); } } @@ -5393,184 +5400,184 @@ namespace Fluid { // ============================================ // ========= Pressure from Temperatures - print(state.files.debug, "Refrigerant={} **** Results ****\n", state.dataFluid->RefrigData(RefrigNum).Name); - if (state.dataFluid->RefrigData(RefrigNum).NumPsPoints > 0) { + print(state.files.debug, "Refrigerant={} **** Results ****\n", state.dataFluidProperties->RefrigData(RefrigNum).Name); + if (state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints > 0) { print(state.files.debug, "Pressure Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop)); Temperature = - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints) + incr); + state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints) + incr); print(state.files.debug, "Saturated Pressures:"); - Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(1) - incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(1) - incr; + ReturnValue = GetSatPressureRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop); ReturnValue = - GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + GetSatPressureRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).PsTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(Loop)) / 2.0; ReturnValue = - GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + GetSatPressureRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints); - ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints); + ReturnValue = GetSatPressureRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluid->RefrigData(RefrigNum).PsTemps(state.dataFluid->RefrigData(RefrigNum).NumPsPoints) + incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).PsTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumPsPoints) + incr; + ReturnValue = GetSatPressureRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Enthalpy from Temperatures - if (state.dataFluid->RefrigData(RefrigNum).NumHPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints > 0) { print(state.files.debug, "Enthalpy Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop)); Temperature = - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints) + incr); + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints) + incr); print(state.files.debug, "Saturated Enthalpy:"); - Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(1) - incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).HTemps(1) - incr; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop); ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).HTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).HTemps(Loop)) / 2.0; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints); ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluid->RefrigData(RefrigNum).HTemps(state.dataFluid->RefrigData(RefrigNum).NumHPoints) + incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).HTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumHPoints) + incr; ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatEnthalpyRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Specific Heat from Temperatures - if (state.dataFluid->RefrigData(RefrigNum).NumCpPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints > 0) { print(state.files.debug, "Specific Heat Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop)); Temperature = - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints) + incr); + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints) + incr); print(state.files.debug, "Saturated Specific Heat:"); - Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(1) - incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(1) - incr; ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop); ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluid->RefrigData(RefrigNum).CpTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop) + + (state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(Loop)) / 2.0; ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints); ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluid->RefrigData(RefrigNum).CpTemps(state.dataFluid->RefrigData(RefrigNum).NumCpPoints) + incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).CpTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumCpPoints) + incr; ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatSpecificHeatRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Density from Temperatures - if (state.dataFluid->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints > 0) { print(state.files.debug, "Density Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)); + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(1) - incr); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop)); Temperature = - state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop + 1) - + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } print(state.files.debug, ",{:.2R}", - state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints)); + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints)); print(state.files.debug, ",{:.2R}\n", - state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints) + incr); + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints) + incr); print(state.files.debug, "Saturated Density:"); - Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(1) - incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(1) - incr; ReturnValue = - GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluid->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop); + for (int Loop = 1; Loop <= state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop); ReturnValue = - GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = - state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluid->RefrigData(RefrigNum).RhoTemps(Loop)) / + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop + 1) - + state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(Loop)) / 2.0; ReturnValue = - GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints); + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints); ReturnValue = - GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluid->RefrigData(RefrigNum).RhoTemps(state.dataFluid->RefrigData(RefrigNum).NumRhoPoints) + incr; + Temperature = state.dataFluidProperties->RefrigData(RefrigNum).RhoTemps(state.dataFluidProperties->RefrigData(RefrigNum).NumRhoPoints) + incr; ReturnValue = - GetSatDensityRefrig(state, state.dataFluid->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + GetSatDensityRefrig(state, state.dataFluidProperties->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } } @@ -5578,6 +5585,79 @@ namespace Fluid { //***************************************************************************** + Real64 RefrigerantData::getSatPressure(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Simon Rees + // DATE WRITTEN 24 May 2002 + + // PURPOSE OF THIS FUNCTION: + // This finds the saturation pressure for given temperature. + + // METHODOLOGY EMPLOYED: + // Calls FindArrayIndex to find indices either side of requested temperature + // and linearly interpolates the corresponding saturation pressure values. + + // FUNCTION PARAMETER DEFINITIONS: + static constexpr std::string_view routineName = "RefrigerantData::getSatPressure"; + + Real64 ReturnValue = 0; + bool ErrorFlag = false; // error flag for current call + + int LoTempIndex = FindArrayIndex(Temperature, this->PsTemps, this->PsLowTempIndex, this->PsHighTempIndex); + int HiTempIndex = LoTempIndex + 1; + + // check for out of data bounds problems + if (LoTempIndex == 0) { + ReturnValue = this->PsValues(this->PsLowTempIndex); + ErrorFlag = true; + } else if (HiTempIndex > this->PsHighTempIndex) { + ReturnValue = this->PsValues(this->PsHighTempIndex); + ErrorFlag = true; + } else { + // find interpolation ratio w.r.t temperature + Real64 TempInterpRatio = (Temperature - this->PsTemps(LoTempIndex)) / (this->PsTemps(HiTempIndex) - this->PsTemps(LoTempIndex)); + + // apply final linear interpolation + ReturnValue = this->PsValues(LoTempIndex) + TempInterpRatio * (this->PsValues(HiTempIndex) - this->PsValues(LoTempIndex)); + } + + if (!state.dataGlobal->WarmupFlag && ErrorFlag) { + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + ++refrigError.SatTempErrCount; + // send warning + if (refrigError.SatTempErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { + ShowSevereMessage(state, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", + routineName, + refrigError.Name)); + ShowContinueError(state, + format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + this->PsTemps(this->PsLowTempIndex), + this->PsTemps(this->PsHighTempIndex))); + ShowContinueError( + state, format("...Supplied Refrigerant Temperature={:.2R} Returned saturated pressure value = {:.0R}", Temperature, ReturnValue)); + ShowContinueErrorTimeStamp(state, ""); + } + ShowRecurringSevereErrorAtEnd(state, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", + routineName, refrigError.Name), + refrigError.SatTempErrIndex, + Temperature, + Temperature, + _, + "{C}", + "{C}"); + } + + return ReturnValue; + } + Real64 GetSatPressureRefrig(EnergyPlusData &state, std::string_view const Refrigerant, // carries in substance name Real64 const Temperature, // actual temperature given as input @@ -5597,29 +5677,20 @@ namespace Fluid { // Calls FindArrayIndex to find indices either side of requested temperature // and linearly interpolates the corresponding saturation pressure values. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatPressureRefrig: "); - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int HiTempIndex; // index value of next highest Temperature from table - int LoTempIndex; // index value of next lowest Temperature from table int RefrigNum; // index for refrigerant under consideration - Real64 TempInterpRatio; // ratio to interpolate in temperature domain // error counters and dummy string bool ErrorFlag; // error flag for current call - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { + if (state.dataFluidProperties->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); } ErrorFlag = false; @@ -5628,67 +5699,94 @@ namespace Fluid { RefrigNum = RefrigIndex; } else { // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); + RefrigNum = GetRefrigNum(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - // determine array indices for - LoTempIndex = FindArrayIndex(Temperature, refrig.PsTemps, refrig.PsLowTempIndex, refrig.PsHighTempIndex); - HiTempIndex = LoTempIndex + 1; + return state.dataFluidProperties->RefrigData(RefrigNum).getSatPressure(state, Temperature, CalledFrom); + } + + //***************************************************************************** + + Real64 RefrigerantData::getSatTemperature(EnergyPlusData &state, + Real64 const Pressure, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Simon Rees + // DATE WRITTEN 24 May 2002 + + // PURPOSE OF THIS FUNCTION: + // This finds the saturation temperature for given pressure. + + // METHODOLOGY EMPLOYED: + // Calls FindArrayIndex to find indices either side of requested pressure + // and linearly interpolates the corresponding saturation temperature values. + + // Return value + Real64 ReturnValue; + + // FUNCTION PARAMETER DEFINITIONS: + static constexpr std::string_view routineName = "RefrigerantData::getSatTemperature"; + + // FUNCTION LOCAL VARIABLE DECLARATIONS: + bool ErrorFlag; // error flag for current call + + // get the array indices + int LoPresIndex = FindArrayIndex(Pressure, this->PsValues, this->PsLowPresIndex, this->PsHighPresIndex); + int HiPresIndex = LoPresIndex + 1; // check for out of data bounds problems - if (LoTempIndex == 0) { - ReturnValue = refrig.PsValues(refrig.PsLowTempIndex); + if (LoPresIndex == 0) { + ReturnValue = this->PsTemps(this->PsLowPresIndex); ErrorFlag = true; - } else if (HiTempIndex > refrig.PsHighTempIndex) { - ReturnValue = refrig.PsValues(refrig.PsHighTempIndex); + } else if (HiPresIndex > this->PsHighPresIndex) { + ReturnValue = this->PsTemps(this->PsHighPresIndex); ErrorFlag = true; } else { // find interpolation ratio w.r.t temperature - TempInterpRatio = (Temperature - refrig.PsTemps(LoTempIndex)) / (refrig.PsTemps(HiTempIndex) - refrig.PsTemps(LoTempIndex)); + Real64 PresInterpRatio = (Pressure - this->PsValues(LoPresIndex)) / (this->PsValues(HiPresIndex) - this->PsValues(LoPresIndex)); // apply final linear interpolation - ReturnValue = refrig.PsValues(LoTempIndex) + TempInterpRatio * (refrig.PsValues(HiTempIndex) - refrig.PsValues(LoTempIndex)); + ReturnValue = this->PsTemps(LoPresIndex) + PresInterpRatio * (this->PsTemps(HiPresIndex) - this->PsTemps(LoPresIndex)); } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrCount; + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + ++refrigError.SatPressErrCount; // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { + if (refrigError.SatPressErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowSevereMessage(state, - format("{}Saturation temperature is out of range for refrigerant [{}] supplied data: **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", + routineName, + refrigError.Name)); ShowContinueError(state, - format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", + format("...Called From:{}, supplied data range=[{:.0R},{:.0R}]", CalledFrom, - refrig.PsTemps(refrig.PsLowTempIndex), - refrig.PsTemps(refrig.PsHighTempIndex))); + this->PsValues(this->PsLowPresIndex), + this->PsValues(this->PsHighPresIndex))); ShowContinueError( - state, format("...Supplied Refrigerant Temperature={:.2R} Returned saturated pressure value = {:.0R}", Temperature, ReturnValue)); + state, format("...Supplied Refrigerant Pressure={:.0R} Returned saturated temperature value ={:.2R}", Pressure, ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } ShowRecurringSevereErrorAtEnd(state, - std::string{RoutineName} + "Saturation temperature is out of range for refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempErrIndex, - Temperature, - Temperature, + format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, refrigError.Name), + refrigError.SatPressErrIndex, + Pressure, + Pressure, _, - "{C}", - "{C}"); + "{Pa}", + "{Pa}"); } - return ReturnValue; } - //***************************************************************************** - Real64 GetSatTemperatureRefrig(EnergyPlusData &state, std::string_view const Refrigerant, // carries in substance name Real64 const Pressure, // actual temperature given as input @@ -5708,29 +5806,19 @@ namespace Fluid { // Calls FindArrayIndex to find indices either side of requested pressure // and linearly interpolates the corresponding saturation temperature values. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatTemperatureRefrig: "); - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int HiPresIndex; // index value of next highest Temperature from table - int LoPresIndex; // index value of next lowest Temperature from table int RefrigNum; // index for refrigerant under consideration - Real64 PresInterpRatio; // ratio to interpolate in temperature domain - // error counters and dummy string bool ErrorFlag; // error flag for current call - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { + if (state.dataFluidProperties->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); } ErrorFlag = false; @@ -5739,10 +5827,10 @@ namespace Fluid { RefrigNum = RefrigIndex; } else { // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); + RefrigNum = GetRefrigNum(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluid->NumOfRefrigerants, + state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -5752,58 +5840,37 @@ namespace Fluid { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - // get the array indices - LoPresIndex = FindArrayIndex(Pressure, refrig.PsValues, refrig.PsLowPresIndex, refrig.PsHighPresIndex); - HiPresIndex = LoPresIndex + 1; + return state.dataFluidProperties->RefrigData(RefrigNum).getSatTemperature(state, Pressure, CalledFrom); + } + + //***************************************************************************** - // check for out of data bounds problems - if (LoPresIndex == 0) { - ReturnValue = refrig.PsTemps(refrig.PsLowPresIndex); - ErrorFlag = true; - } else if (HiPresIndex > refrig.PsHighPresIndex) { - ReturnValue = refrig.PsTemps(refrig.PsHighPresIndex); - ErrorFlag = true; - } else { - // find interpolation ratio w.r.t temperature - PresInterpRatio = (Pressure - refrig.PsValues(LoPresIndex)) / (refrig.PsValues(HiPresIndex) - refrig.PsValues(LoPresIndex)); + Real64 RefrigerantData::getSatEnthalpy(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { - // apply final linear interpolation - ReturnValue = refrig.PsTemps(LoPresIndex) + PresInterpRatio * (refrig.PsTemps(HiPresIndex) - refrig.PsTemps(LoPresIndex)); - } + // SUBROUTINE INFORMATION: + // AUTHOR Mike Turner + // DATE WRITTEN 10 December 99 + // MODIFIED Rick Strand (April 2000, May 2000) + // Simon Rees (May 2002) - if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrCount; - // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { - ShowSevereMessage(state, - format("{}Saturation pressure is out of range for refrigerant [{}] supplied data: **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); - ShowContinueError(state, - format("...Called From:{}, supplied data range=[{:.0R},{:.0R}]", - CalledFrom, - refrig.PsValues(refrig.PsLowPresIndex), - refrig.PsValues(refrig.PsHighPresIndex))); - ShowContinueError( - state, format("...Supplied Refrigerant Pressure={:.0R} Returned saturated temperature value ={:.2R}", Pressure, ReturnValue)); - ShowContinueErrorTimeStamp(state, ""); - } - ShowRecurringSevereErrorAtEnd(state, - std::string{RoutineName} + "Saturation pressure is out of range for refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatPressErrIndex, - Pressure, - Pressure, - _, - "{Pa}", - "{Pa}"); - } - return ReturnValue; - } + // PURPOSE OF THIS FUNCTION: + // This finds enthalpy for given temperature and a quality under the vapor dome. + // This fucntion is only called with a valid refrigerant and quality between 0 and 1. - //***************************************************************************** + // METHODOLOGY EMPLOYED: + // Calls GetInterpolatedSatProp to linearly interpolate between the saturated + // liquid and vapour enthalpies according to the given quality. + + // Apply linear interpolation function + return GetInterpolatedSatProp( + state, Temperature, this->HTemps, this->HfValues, this->HfgValues, Quality, CalledFrom, this->HfLowTempIndex, this->HfHighTempIndex); + } Real64 GetSatEnthalpyRefrig(EnergyPlusData &state, std::string_view const Refrigerant, // carries in substance name @@ -5834,15 +5901,15 @@ namespace Fluid { // FUNCTION LOCAL VARIABLE DECLARATIONS: int RefrigNum; // index for refrigerant under consideration - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { + if (state.dataFluidProperties->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } if ((Quality < 0.0) || (Quality > 1.0)) { @@ -5855,28 +5922,23 @@ namespace Fluid { RefrigNum = RefrigIndex; } else { // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); + RefrigNum = GetRefrigNum(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - // Apply linear interpolation function - return GetInterpolatedSatProp( - state, Temperature, refrig.HTemps, refrig.HfValues, refrig.HfgValues, Quality, CalledFrom, refrig.HfLowTempIndex, refrig.HfHighTempIndex); + return state.dataFluidProperties->RefrigData(RefrigNum).getSatEnthalpy(state, Temperature, Quality, CalledFrom); } - + //***************************************************************************** - Real64 GetSatDensityRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 RefrigerantData::getSatDensity(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -5898,80 +5960,47 @@ namespace Fluid { Real64 ReturnValue; // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatDensityRefrig: "); - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - Real64 LoSatProp; // Sat. prop. at lower temp & given quality - Real64 HiSatProp; // Sat. prop. at higher temp & given quality - Real64 TempInterpRatio; // ratio to interpolate in temperature domain - - // error counters and dummy string - - if (state.dataFluid->GetInput) { - GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; - } - - int RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); - } + static constexpr std::string_view routineName = "RefrigerantData::getSatDensity"; if ((Quality < 0.0) || (Quality > 1.0)) { - ShowSevereError(state, fmt::format("{}Refrigerant \"{}\", invalid quality, called from {}", RoutineName, Refrigerant, CalledFrom)); + ShowSevereError(state, fmt::format("{}Refrigerant \"{}\", invalid quality, called from {}", routineName, this->Name, CalledFrom)); ShowContinueError(state, format("Saturated density quality must be between 0 and 1, entered value=[{:.4R}].", Quality)); ShowFatalError(state, "Program terminates due to preceding condition."); } - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); - } - RefrigIndex = RefrigNum; - } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - bool ErrorFlag = false; - int LoTempIndex = FindArrayIndex(Temperature, refrig.RhoTemps, refrig.RhofLowTempIndex, refrig.RhofHighTempIndex); + int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, this->RhofLowTempIndex, this->RhofHighTempIndex); int HiTempIndex = LoTempIndex + 1; // Error check to make sure the temperature is not out of bounds if (LoTempIndex == 0) { // Give the lowest density value if the temperature is below than the minimum // temperature in the refrigerant table - ReturnValue = 1.0 / refrig.RhofValues(refrig.RhofLowTempIndex) + - Quality * (1.0 / refrig.RhofgValues(refrig.RhofLowTempIndex) - 1.0 / refrig.RhofValues(refrig.RhofLowTempIndex)); + ReturnValue = 1.0 / this->RhofValues(this->RhofLowTempIndex) + + Quality * (1.0 / this->RhofgValues(this->RhofLowTempIndex) - 1.0 / this->RhofValues(this->RhofLowTempIndex)); ReturnValue = 1.0 / ReturnValue; ErrorFlag = true; - } else if (HiTempIndex > refrig.RhofHighTempIndex) { + } else if (HiTempIndex > this->RhofHighTempIndex) { // Give the highest density value if the temperature is higher than the maximum // temperature in the refrigerant table - ReturnValue = 1.0 / refrig.RhofValues(refrig.RhofHighTempIndex) + - Quality * (1.0 / refrig.RhofgValues(refrig.RhofHighTempIndex) - 1.0 / refrig.RhofValues(refrig.RhofHighTempIndex)); + ReturnValue = 1.0 / this->RhofValues(this->RhofHighTempIndex) + + Quality * (1.0 / this->RhofgValues(this->RhofHighTempIndex) - 1.0 / this->RhofValues(this->RhofHighTempIndex)); ReturnValue = 1.0 / ReturnValue; ErrorFlag = true; } else { // Okay // Calculate the specific volume for the lower temperature index based on linear // interpolation of the quality - LoSatProp = - 1.0 / refrig.RhofValues(LoTempIndex) + Quality * (1.0 / refrig.RhofgValues(LoTempIndex) - 1.0 / refrig.RhofValues(LoTempIndex)); + Real64 LoSatProp = + 1.0 / this->RhofValues(LoTempIndex) + Quality * (1.0 / this->RhofgValues(LoTempIndex) - 1.0 / this->RhofValues(LoTempIndex)); // Calculate the specific volume for the higher temperature index based on linear // interpolation of the quality - HiSatProp = - 1.0 / refrig.RhofValues(HiTempIndex) + Quality * (1.0 / refrig.RhofgValues(HiTempIndex) - 1.0 / refrig.RhofValues(HiTempIndex)); + Real64 HiSatProp = + 1.0 / this->RhofValues(HiTempIndex) + Quality * (1.0 / this->RhofgValues(HiTempIndex) - 1.0 / this->RhofValues(HiTempIndex)); // Find interpolation ratio in temperature direction - TempInterpRatio = (Temperature - refrig.RhoTemps(LoTempIndex)) / (refrig.RhoTemps(HiTempIndex) - refrig.RhoTemps(LoTempIndex)); + Real64 TempInterpRatio = (Temperature - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(HiTempIndex) - this->RhoTemps(LoTempIndex)); // Apply final linear interpolation to find the specific volume ReturnValue = LoSatProp + TempInterpRatio * (HiSatProp - LoSatProp); @@ -5980,26 +6009,26 @@ namespace Fluid { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - ++state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount; + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + ++refrigError.SatTempDensityErrCount; // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { + if (refrigError.SatTempDensityErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowSevereMessage(state, - format("{}Saturation temperature is out of range for refrigerant [{}] supplied data: **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", + routineName, + refrigError.Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, - refrig.RhoTemps(refrig.RhofLowTempIndex), - refrig.RhoTemps(refrig.RhofHighTempIndex))); + this->RhoTemps(this->RhofLowTempIndex), + this->RhoTemps(this->RhofHighTempIndex))); ShowContinueError( state, format("...Supplied Refrigerant Temperature={:.2R} Returned saturated density value ={:.2R}", Temperature, ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } ShowRecurringSevereErrorAtEnd(state, - std::string{RoutineName} + "Saturation temperature is out of range for refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + "] supplied data: **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrIndex, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, refrigError.Name), + refrigError.SatTempDensityErrIndex, Temperature, Temperature, _, @@ -6009,8 +6038,113 @@ namespace Fluid { return ReturnValue; } + Real64 GetSatDensityRefrig(EnergyPlusData &state, + std::string_view const Refrigerant, // carries in substance name + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Mike Turner + // DATE WRITTEN 10 December 99 + // MODIFIED Rick Strand (April 2000, May 2000) + // Simon Rees (May 2002); Kenneth Tang (Jan 2004) + + // PURPOSE OF THIS SUBROUTINE: + // This finds density for given temperature and a quality under the vapor dome. + // This function is only called with a valid refrigerant and quality between 0 and 1. + + // METHODOLOGY EMPLOYED: + // Calls GetInterpolatedSatProp to linearly interpolate between the saturated + // liquid and vapour densities according to the given quality. + + // FUNCTION PARAMETER DEFINITIONS: + static constexpr std::string_view RoutineName("GetSatDensityRefrig: "); + + // error counters and dummy string + + if (state.dataFluidProperties->GetInput) { + GetFluidPropertiesData(state); + state.dataFluidProperties->GetInput = false; + } + + int RefrigNum = 0; + if (state.dataFluidProperties->NumOfRefrigerants == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); + } + + if ((Quality < 0.0) || (Quality > 1.0)) { + ShowSevereError(state, fmt::format("{}Refrigerant \"{}\", invalid quality, called from {}", RoutineName, Refrigerant, CalledFrom)); + ShowContinueError(state, format("Saturated density quality must be between 0 and 1, entered value=[{:.4R}].", Quality)); + ShowFatalError(state, "Program terminates due to preceding condition."); + } + + // Find which refrigerant (index) is being requested and then determine + // where the temperature is within the temperature array + if (RefrigIndex > 0) { + RefrigNum = RefrigIndex; + } else { + // Find which refrigerant (index) is being requested + RefrigNum = GetRefrigNum(state, Refrigerant); + if (RefrigNum == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); + } + RefrigIndex = RefrigNum; + } + + return state.dataFluidProperties->RefrigData(RefrigNum).getSatDensity(state, Temperature, Quality, CalledFrom); + } + //***************************************************************************** + Real64 RefrigerantData::getSatSpecificHeat(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Mike Turner + // DATE WRITTEN 10 December 99 + // MODIFIED Rick Strand (April 2000, May 2000) + // Simon Rees (May 2002) + + // PURPOSE OF THIS SUBROUTINE: + // This finds specific heat for given temperature and a quality under the vapor dome. + // This fucntion is only called with a valid refrigerant and quality between 0 and 1. + + // METHODOLOGY EMPLOYED: + // Calls GetInterpolatedSatProp to linearly interpolate between the saturated + // liquid and vapour specific heats according to the given quality. + + // FUNCTION PARAMETER DEFINITIONS: + static constexpr std::string_view routineName = "RefrigerantData::getSatSpecificHeat"; + + if ((Quality < 0.0) || (Quality > 1.0)) { + ShowSevereError(state, fmt::format("{}: Refrigerant \"{}\", invalid quality, called from {}", routineName, this->Name, CalledFrom)); + ShowContinueError(state, format("Saturated density quality must be between 0 and 1, entered value=[{:.4R}].", Quality)); + ShowFatalError(state, "Program terminates due to preceding condition."); + } + + // Apply linear interpolation function + return GetInterpolatedSatProp(state, + Temperature, + this->CpTemps, + this->CpfValues, + this->CpfgValues, + Quality, + CalledFrom, + this->CpfLowTempIndex, + this->CpfHighTempIndex); + + } + Real64 GetSatSpecificHeatRefrig(EnergyPlusData &state, std::string_view const Refrigerant, // carries in substance name Real64 const Temperature, // actual temperature given as input @@ -6034,21 +6168,18 @@ namespace Fluid { // Calls GetInterpolatedSatProp to linearly interpolate between the saturated // liquid and vapour specific heats according to the given quality. - // Return value - Real64 ReturnValue; - // FUNCTION PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("GetSatSpecificHeatRefrig: "); - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } int RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { + if (state.dataFluidProperties->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatSpecificHeatRefrig", "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatSpecificHeatRefrig", "properties", CalledFrom); } if ((Quality < 0.0) || (Quality > 1.0)) { @@ -6063,10 +6194,10 @@ namespace Fluid { RefrigNum = RefrigIndex; } else { // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); + RefrigNum = GetRefrigNum(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluid->NumOfRefrigerants, + state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -6076,30 +6207,16 @@ namespace Fluid { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - - // Apply linear interpolation function - ReturnValue = GetInterpolatedSatProp(state, - Temperature, - refrig.CpTemps, - refrig.CpfValues, - refrig.CpfgValues, - Quality, - CalledFrom, - refrig.CpfLowTempIndex, - refrig.CpfHighTempIndex); - return ReturnValue; + return state.dataFluidProperties->RefrigData(RefrigNum).getSatSpecificHeat(state, Temperature, Quality, CalledFrom); } //***************************************************************************** - Real64 GetSupHeatEnthalpyRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 RefrigerantData::getSupHeatEnthalpy(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -6129,65 +6246,29 @@ namespace Fluid { Real64 ReturnValue; // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSupHeatEnthalpyRefrig: "); - static constexpr std::string_view RoutineNameNoSpace("GetSupHeatEnthalpyRefrig:"); - static constexpr std::string_view RoutineNameNoColon("GetSupHeatEnthalpyRefrig"); - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - Real64 PressInterpRatio; // Interpolation factor w.r.t pressure - Real64 TempInterpRatio; // Interpolation factor w.r.t temperature - Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature - Real64 EnthalpyLow; // Enthalpy value at interpolated pressure and low temperature - Real64 LoTempLoEnthalpy; // Enthalpy value at low pressure and low temperature - Real64 LoTempHiEnthalpy; // Enthalpy value at high pressure and low temperature - Real64 HiTempLoEnthalpy; // Enthalpy value at low pressure and high temperature - Real64 HiTempHiEnthalpy; // Enthalpy value at high pressure and high temperature + static constexpr std::string_view routineName = "RefrigerantData::getSupHeatEnthalpy"; int HiTempIndex; // high temperature index value int HiPressIndex; // high pressure index value - // see if data is there - if (state.dataFluid->GetInput) { - GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; - } - - int RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); - } + // SUBROUTINE LOCAL VARIABLE DECLARATIONS: + Real64 PressInterpRatio; // Interpolation factor w.r.t pressure + Real64 TempInterpRatio; // Interpolation factor w.r.t temperature // error counters and dummy string int ErrCount = 0; int CurTempRangeErrCount = 0; int CurPresRangeErrCount = 0; - // Find which refrigerant (index) is being requested and then determine - // where the temperature and pressure are within the temperature and - // pressure arrays, respectively - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineNameNoColon, "properties", CalledFrom); - } - RefrigIndex = RefrigNum; - } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - // low index value of Temperature from table - int TempIndex = FindArrayIndex(Temperature, refrig.SHTemps, 1, refrig.NumSuperTempPts); + int TempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); // low index value of Pressure from table - int LoPressIndex = FindArrayIndex(Pressure, refrig.SHPress, 1, refrig.NumSuperPressPts); + int LoPressIndex = FindArrayIndex(Pressure, this->SHPress, 1, this->NumSuperPressPts); // check temperature data range and attempt to cap if necessary - if ((TempIndex > 0) && (TempIndex < refrig.NumSuperTempPts)) { // in range + if ((TempIndex > 0) && (TempIndex < this->NumSuperTempPts)) { // in range HiTempIndex = TempIndex + 1; - TempInterpRatio = (Temperature - refrig.SHTemps(TempIndex)) / (refrig.SHTemps(HiTempIndex) - refrig.SHTemps(TempIndex)); + TempInterpRatio = (Temperature - this->SHTemps(TempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(TempIndex)); } else if (TempIndex < 1) { ++CurTempRangeErrCount; ++ErrCount; @@ -6203,9 +6284,9 @@ namespace Fluid { } // check pressure data range and attempt to cap if necessary - if ((LoPressIndex > 0) && (LoPressIndex < refrig.NumSuperPressPts)) { // in range + if ((LoPressIndex > 0) && (LoPressIndex < this->NumSuperPressPts)) { // in range HiPressIndex = LoPressIndex + 1; - PressInterpRatio = (Pressure - refrig.SHPress(LoPressIndex)) / (refrig.SHPress(HiPressIndex) - refrig.SHPress(LoPressIndex)); + PressInterpRatio = (Pressure - this->SHPress(LoPressIndex)) / (this->SHPress(HiPressIndex) - this->SHPress(LoPressIndex)); } else if (LoPressIndex < 1) { ++CurPresRangeErrCount; ++ErrCount; @@ -6221,52 +6302,52 @@ namespace Fluid { } // get interpolation point values - LoTempLoEnthalpy = refrig.HshValues(LoPressIndex, TempIndex); - LoTempHiEnthalpy = refrig.HshValues(HiPressIndex, TempIndex); - HiTempLoEnthalpy = refrig.HshValues(LoPressIndex, HiTempIndex); - HiTempHiEnthalpy = refrig.HshValues(HiPressIndex, HiTempIndex); + Real64 LoTempLoEnthalpy = this->HshValues(LoPressIndex, TempIndex); + Real64 LoTempHiEnthalpy = this->HshValues(HiPressIndex, TempIndex); + Real64 HiTempLoEnthalpy = this->HshValues(LoPressIndex, HiTempIndex); + Real64 HiTempHiEnthalpy = this->HshValues(HiPressIndex, HiTempIndex); // to give reasonable interpolation near saturation reset any point with zero value // in table to saturation value if (LoTempLoEnthalpy <= 0.0) { - LoTempLoEnthalpy = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, RoutineNameNoColon); + LoTempLoEnthalpy = this->getSatEnthalpy(state, Temperature, 1.0, routineName); } if (LoTempHiEnthalpy <= 0.0) { - LoTempHiEnthalpy = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, RoutineNameNoColon); + LoTempHiEnthalpy = this->getSatEnthalpy(state, Temperature, 1.0, routineName); } if (HiTempLoEnthalpy <= 0.0) { - HiTempLoEnthalpy = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, RoutineNameNoColon); + HiTempLoEnthalpy = this->getSatEnthalpy(state, Temperature, 1.0, routineName); } if (HiTempHiEnthalpy <= 0.0) { - HiTempHiEnthalpy = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, RoutineNameNoColon); + HiTempHiEnthalpy = this->getSatEnthalpy(state, Temperature, 1.0, routineName); } // interpolate w.r.t. pressure - EnthalpyLow = PressInterpRatio * LoTempHiEnthalpy + (1.0 - PressInterpRatio) * LoTempLoEnthalpy; + Real64 EnthalpyLow = PressInterpRatio * LoTempHiEnthalpy + (1.0 - PressInterpRatio) * LoTempLoEnthalpy; - EnthalpyHigh = PressInterpRatio * HiTempHiEnthalpy + (1.0 - PressInterpRatio) * HiTempLoEnthalpy; + Real64 EnthalpyHigh = PressInterpRatio * HiTempHiEnthalpy + (1.0 - PressInterpRatio) * HiTempLoEnthalpy; // interpolate w.r.t. temperature ReturnValue = TempInterpRatio * EnthalpyHigh + (1.0 - TempInterpRatio) * EnthalpyLow; // Check to see if all data is at zero. In this case we are completely // inside the saturation dome. Best thing we can do is return saturation value - if ((refrig.HshValues(LoPressIndex, TempIndex) <= 0.0) && (refrig.HshValues(HiPressIndex, TempIndex) <= 0.0) && - (refrig.HshValues(LoPressIndex, HiTempIndex) <= 0.0) && (refrig.HshValues(HiPressIndex, HiTempIndex) <= 0.0)) { - ++state.dataFluid->SatErrCountGetSupHeatEnthalpyRefrig; + if ((this->HshValues(LoPressIndex, TempIndex) <= 0.0) && (this->HshValues(HiPressIndex, TempIndex) <= 0.0) && + (this->HshValues(LoPressIndex, HiTempIndex) <= 0.0) && (this->HshValues(HiPressIndex, HiTempIndex) <= 0.0)) { + ++state.dataFluidProperties->SatErrCountGetSupHeatEnthalpyRefrig; // set return value - ReturnValue = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); + ReturnValue = this->getSatEnthalpy(state, Temperature, 1.0, fmt::format("{}:{}", routineName, CalledFrom)); // send warning if (!state.dataGlobal->WarmupFlag) { - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrCount += - state.dataFluid->SatErrCountGetSupHeatEnthalpyRefrig; + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + refrigError.SatSupEnthalpyErrCount += state.dataFluidProperties->SatErrCountGetSupHeatEnthalpyRefrig; // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatTempDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { + if (refrigError.SatTempDensityErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage( state, - format("{}Refrigerant [{}] is saturated at the given conditions, saturated enthalpy at given temperature returned. **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] is saturated at the given conditions, saturated enthalpy at given temperature returned. **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); @@ -6274,10 +6355,8 @@ namespace Fluid { ShowContinueErrorTimeStamp(state, ""); } ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] saturated at the given conditions **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, + format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, refrigError.Name), + refrigError.SatSupEnthalpyErrIndex, Temperature, Temperature, _, @@ -6291,22 +6370,22 @@ namespace Fluid { // some checks... if (ErrCount > 0) { // send temp range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + refrigError.SatSupEnthalpyTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && refrigError.SatSupEnthalpyTempErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage(state, - format("{}Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Temperature is out of range for superheated refrigerant enthalpy: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyTempErrIndex, + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", + routineName, + refrigError.Name), + refrigError.SatSupEnthalpyTempErrIndex, Temperature, Temperature, _, @@ -6315,22 +6394,19 @@ namespace Fluid { } // send pressure range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + refrigError.SatSupEnthalpyPresErrCount += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && refrigError.SatSupEnthalpyPresErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage(state, - format("{}Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyPresErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, refrigError.Name), + refrigError.SatSupEnthalpyPresErrIndex, Pressure, Pressure, _, @@ -6343,14 +6419,76 @@ namespace Fluid { return ReturnValue; } + Real64 GetSupHeatEnthalpyRefrig(EnergyPlusData &state, + std::string_view const Refrigerant, // carries in substance name + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Mike Turner + // DATE WRITTEN 10 December 99 + // MODIFIED Rick Strand (April 2000, May 2000) + // MODIFIED Simon Rees (May 2002) + + // PURPOSE OF THIS SUBROUTINE: + // Performs linear interpolation between pressures and temperatures and + // returns enthalpy values. Works only in superheated region. + + // METHODOLOGY EMPLOYED: + // Double linear interpolation is used with enthalpy values at four + // pressure/temperature input points surrounding the given temperature + // and pressure argument values. + // With enthalpy data it is assumed that zero values in the data are in + // the saturated region. Hence, values near the saturation line are + // approximated using the saturation value instead of the zero data value. + // points completely in the saturation region are given the saturation value + // at the given temperature. Points at the upper limits of pressure/temperature + // have the pressure/temperature capped. Warnings are given if the point + // is not clearly in the bounds of the superheated data. + + // FUNCTION PARAMETER DEFINITIONS: + static constexpr std::string_view routineName = "GetSupHeatEnthalpyRefrig"; + + // see if data is there + if (state.dataFluidProperties->GetInput) { + GetFluidPropertiesData(state); + state.dataFluidProperties->GetInput = false; + } + + int RefrigNum = 0; + if (state.dataFluidProperties->NumOfRefrigerants == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, routineName, "properties", CalledFrom); + } + + // Find which refrigerant (index) is being requested and then determine + // where the temperature and pressure are within the temperature and + // pressure arrays, respectively + if (RefrigIndex > 0) { + RefrigNum = RefrigIndex; + } else { + // Find which refrigerant (index) is being requested + RefrigNum = GetRefrigNum(state, Refrigerant); + if (RefrigNum == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, routineName, "properties", CalledFrom); + } + RefrigIndex = RefrigNum; + } + + return state.dataFluidProperties->RefrigData(RefrigNum).getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); + } + //***************************************************************************** - Real64 GetSupHeatPressureRefrig(EnergyPlusData &state, - std::string const &Refrigerant, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Enthalpy, // actual enthalpy given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 RefrigerantData::getSupHeatPressure(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Enthalpy, // actual enthalpy given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -6380,8 +6518,7 @@ namespace Fluid { // FUNCTION PARAMETERS: // the enthalpy calculated from the pressure found - static constexpr std::string_view RoutineName("GetSupHeatPressureRefrig: "); - static constexpr std::string_view RoutineNameNoSpace("GetSupHeatPressureRefrig:"); + static constexpr std::string_view routineName = "GetSupHeatPressureRefrig"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 EnthalpyCheck; // recalculates enthalpy based on calculated pressure @@ -6394,53 +6531,21 @@ namespace Fluid { int middle; // mid-point for interval halving - int HiTempIndex; // Index value of higher temperature from data - int LoEnthalpyIndex; // Index value of lower enthalpy from data - int HiEnthalpyIndex; // Index value of higher enthalpy from data - - if (state.dataFluid->GetInput) { - GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; - } - - int RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); - } - - // error counters and dummy string - int ErrCount = 0; - int CurTempRangeErrCount = 0; - int CurEnthalpyRangeErrCount = 0; - int CurSatErrCount = 0; - - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors(state, - state.dataFluid->NumOfRefrigerants, - RefrigNum, - true, - Refrigerant, - "GetSupHeatPressureRefrig", - "properties", - CalledFrom); - } - RefrigIndex = RefrigNum; - } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); + int HiTempIndex; // Index value of higher temperature from data + int LoEnthalpyIndex; // Index value of lower enthalpy from data + int HiEnthalpyIndex; // Index value of higher enthalpy from data + + // error counters and dummy string + int ErrCount = 0; + int CurTempRangeErrCount = 0; + int CurEnthalpyRangeErrCount = 0; + int CurSatErrCount = 0; // Index value of lower temperature from data - int LoTempIndex = FindArrayIndex(Temperature, refrig.SHTemps, 1, refrig.NumSuperTempPts); + int LoTempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); // check temperature data range and attempt to cap if necessary - if ((LoTempIndex > 0) && (LoTempIndex < refrig.NumSuperTempPts)) { // in range + if ((LoTempIndex > 0) && (LoTempIndex < this->NumSuperTempPts)) { // in range HiTempIndex = LoTempIndex + 1; } else if (LoTempIndex < 1) { // below lower bound ++CurTempRangeErrCount; @@ -6452,25 +6557,25 @@ namespace Fluid { } // check for lowest non-zero value in lower temp data - int LoTempStart = refrig.NumSuperPressPts; - for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { - if (refrig.HshValues(Loop, LoTempIndex) > 0.0) { + int LoTempStart = this->NumSuperPressPts; + for (int Loop = 1; Loop <= this->NumSuperPressPts; ++Loop) { + if (this->HshValues(Loop, LoTempIndex) > 0.0) { LoTempStart = Loop; break; } } // check for highest non-zero value in lower temp data int LoTempFinish = 1; - for (int Loop = refrig.NumSuperPressPts; Loop >= 1; --Loop) { - if (refrig.HshValues(Loop, LoTempIndex) <= 0.0) { + for (int Loop = this->NumSuperPressPts; Loop >= 1; --Loop) { + if (this->HshValues(Loop, LoTempIndex) <= 0.0) { LoTempFinish = Loop; // EXIT } } // check for lowest non-zero value in high temp data - int HiTempStart = refrig.NumSuperPressPts; - for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { - if (refrig.HshValues(Loop, HiTempIndex) > 0.0) { + int HiTempStart = this->NumSuperPressPts; + for (int Loop = 1; Loop <= this->NumSuperPressPts; ++Loop) { + if (this->HshValues(Loop, HiTempIndex) > 0.0) { HiTempStart = Loop; break; } @@ -6478,8 +6583,8 @@ namespace Fluid { // check for highest non-zero value in high temp data int HiTempFinish = 1; - for (int Loop = refrig.NumSuperPressPts; Loop >= 1; --Loop) { - if (refrig.HshValues(Loop, HiTempIndex) <= 0.0) { + for (int Loop = this->NumSuperPressPts; Loop >= 1; --Loop) { + if (this->HshValues(Loop, HiTempIndex) <= 0.0) { HiTempFinish = Loop; } } @@ -6490,17 +6595,17 @@ namespace Fluid { int TempFinish = min(LoTempFinish, HiTempFinish); // calculate interpolation ratio w.r.t temperature // This ratio is used to find enthalpies at the given temperature - Real64 TempInterpRatio = (Temperature - refrig.SHTemps(LoTempIndex)) / (refrig.SHTemps(HiTempIndex) - refrig.SHTemps(LoTempIndex)); + Real64 TempInterpRatio = (Temperature - this->SHTemps(LoTempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(LoTempIndex)); // search for array index by bisection int start = TempStart; // set the bounds int finish = TempFinish; // find the bounds of the enthalpy data available - EnthalpyMax = max(refrig.HshValues(TempStart, LoTempIndex), refrig.HshValues(TempStart, HiTempIndex)); - EnthalpyMin = min(refrig.HshValues(TempFinish, LoTempIndex), refrig.HshValues(TempFinish, HiTempIndex)); + EnthalpyMax = max(this->HshValues(TempStart, LoTempIndex), this->HshValues(TempStart, HiTempIndex)); + EnthalpyMin = min(this->HshValues(TempFinish, LoTempIndex), this->HshValues(TempFinish, HiTempIndex)); // get saturated enthalpy for checking - SatEnthalpy = GetSatEnthalpyRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); + SatEnthalpy = this->getSatEnthalpy(state, Temperature, 1.0, fmt::format("{}:{}", routineName, CalledFrom)); // make some checks on the data before interpolating if (Enthalpy < SatEnthalpy) { @@ -6508,7 +6613,7 @@ namespace Fluid { ++CurSatErrCount; ++ErrCount; // return sat pressure at this temperature - ReturnValue = GetSatPressureRefrig(state, Refrigerant, Temperature, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); + ReturnValue = this->getSatPressure(state, Temperature, fmt::format("{}:{}", routineName, CalledFrom)); } else if (EnthalpyMax < Enthalpy || EnthalpyMin > Enthalpy) { // out of range error @@ -6516,10 +6621,10 @@ namespace Fluid { ++ErrCount; if (Enthalpy > EnthalpyMax) { // return min pressure - ReturnValue = refrig.SHPress(HiTempStart); + ReturnValue = this->SHPress(HiTempStart); } else { // return max pressure - ReturnValue = refrig.SHPress(LoTempFinish); + ReturnValue = this->SHPress(LoTempFinish); } } else { // go ahead and search @@ -6527,8 +6632,8 @@ namespace Fluid { middle = (finish + start) / 2; // calc enthalpy at middle index for given temperature - EnthalpyCheck = refrig.HshValues(middle, LoTempIndex) + - TempInterpRatio * (refrig.HshValues(middle, HiTempIndex) - refrig.HshValues(middle, LoTempIndex)); + EnthalpyCheck = this->HshValues(middle, LoTempIndex) + + TempInterpRatio * (this->HshValues(middle, HiTempIndex) - this->HshValues(middle, LoTempIndex)); if (Enthalpy < EnthalpyCheck) { start = middle; @@ -6540,29 +6645,30 @@ namespace Fluid { HiEnthalpyIndex = start + 1; // calculate enthalpies adjacent specified enthalpy at given temperature - EnthalpyLow = refrig.HshValues(LoEnthalpyIndex, LoTempIndex) + - TempInterpRatio * (refrig.HshValues(LoEnthalpyIndex, HiTempIndex) - refrig.HshValues(LoEnthalpyIndex, LoTempIndex)); + EnthalpyLow = this->HshValues(LoEnthalpyIndex, LoTempIndex) + + TempInterpRatio * (this->HshValues(LoEnthalpyIndex, HiTempIndex) - this->HshValues(LoEnthalpyIndex, LoTempIndex)); - EnthalpyHigh = refrig.HshValues(HiEnthalpyIndex, LoTempIndex) + - TempInterpRatio * (refrig.HshValues(HiEnthalpyIndex, HiTempIndex) - refrig.HshValues(HiEnthalpyIndex, LoTempIndex)); + EnthalpyHigh = this->HshValues(HiEnthalpyIndex, LoTempIndex) + + TempInterpRatio * (this->HshValues(HiEnthalpyIndex, HiTempIndex) - this->HshValues(HiEnthalpyIndex, LoTempIndex)); // calculate an interpolation ratio EnthInterpRatio = (Enthalpy - EnthalpyLow) / (EnthalpyHigh - EnthalpyLow); // apply this interpolation ratio to find the final pressure - ReturnValue = refrig.SHPress(LoEnthalpyIndex) + EnthInterpRatio * (refrig.SHPress(HiEnthalpyIndex) - refrig.SHPress(LoEnthalpyIndex)); + ReturnValue = this->SHPress(LoEnthalpyIndex) + EnthInterpRatio * (this->SHPress(HiEnthalpyIndex) - this->SHPress(LoEnthalpyIndex)); } if (!state.dataGlobal->WarmupFlag) { // ** make error checks ** if (ErrCount > 0) { // send near saturation warning if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount += CurSatErrCount; + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + refrigError.SatSupPressureErrCount += CurSatErrCount; // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { + if (refrigError.SatSupPressureErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowSevereMessage(state, - format("{}Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " + format("{}: Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " "temperature returned. **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant Enthalpy = {:.3R}", Enthalpy)); @@ -6571,10 +6677,8 @@ namespace Fluid { } if (CurSatErrCount > 0) { ShowRecurringSevereErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] saturated at the given enthalpy and temperature **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureErrIndex, + format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, refrigError.Name), + refrigError.SatSupPressureErrIndex, ReturnValue, ReturnValue, _, @@ -6583,22 +6687,19 @@ namespace Fluid { } // send temp range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + refrigError.SatSupPressureTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && refrigError.SatSupPressureTempErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage(state, - format("{}Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Temperature is out of range for superheated refrigerant pressure: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureTempErrIndex, + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", routineName, refrigError.Name), + refrigError.SatSupPressureTempErrIndex, Temperature, Temperature, _, @@ -6607,22 +6708,19 @@ namespace Fluid { } // send enthalpy range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount += CurEnthalpyRangeErrCount; - if (CurEnthalpyRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + refrigError.SatSupPressureEnthErrCount += CurEnthalpyRangeErrCount; + if (CurEnthalpyRangeErrCount > 0 && refrigError.SatSupPressureEnthErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage(state, - format("{}Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurEnthalpyRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Pressure is out of range for superheated refrigerant pressure: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupPressureEnthErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant pressure: values capped **", routineName, refrigError.Name), + refrigError.SatSupPressureEnthErrIndex, Enthalpy, Enthalpy, _, @@ -6635,54 +6733,46 @@ namespace Fluid { return ReturnValue; } - //***************************************************************************** - Real64 GetSupHeatTempRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name - Real64 const Pressure, // actual pressure given as input - Real64 const Enthalpy, // actual enthalpy given as input - Real64 TempLow, // lower bound of temperature in the iteration - Real64 TempUp, // upper bound of temperature in the iteration - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GetSupHeatPressureRefrig(EnergyPlusData &state, + std::string const &Refrigerant, // carries in substance name + Real64 const Temperature, // actual temperature given as input + Real64 const Enthalpy, // actual enthalpy given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { + // SUBROUTINE INFORMATION: - // AUTHOR Rongpeng Zhang - // DATE WRITTEN Jan 2016 + // AUTHOR Rick Strand + // DATE WRITTEN May 2000 + // MODIFIED Simon Rees (May 2002) // PURPOSE OF THIS SUBROUTINE: - // Performs iterations to calculate the refrigerant temperature corresponding to the given - // enthalpy and pressure. Works only in superheated region. + // Performs linear interpolation between enthalpy and temperatures and + // returns pressure values. Works only in superheated region. // METHODOLOGY EMPLOYED: - // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. - - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETERS: - // the enthalpy calculated from the pressure found - static constexpr std::string_view RoutineName("GetSupHeatTempRefrig: "); - static constexpr std::string_view RoutineNameNoSpace("GetSupHeatTempRefrig:"); - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - int RefrigNum; // index for refrigerant under consideration - Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature - Real64 EnthalpyLow; // Enthalpy value at interpolated pressure and low temperature - Real64 RefTHigh; // High Temperature Value for Ps (max in tables) - Real64 RefTSat; // Saturated temperature of the refrigerant. Used to check whether the refrigernat is in the superheat area - Real64 Temp; // Temperature of the superheated refrigerant at the given enthalpy and pressure + // Double linear interpolation is used with pressure values at four + // enthalpy/temperature input points surrounding the given temperature + // and enthalpy argument values. + // All enthalpies have to be calculated at the given temperature before a + // search is made for the data adjacent to the given enthalpy. Linear interpolation + // using the enthalpy data is used to interpolate the correspondng pressures. + // Temperatures and enthalpies outside the bounds of the available data are capped + // and warnings given. For enthlpys lower than the saturated vapour value at the + // given temperature result in the saturation pressure being returned (calls to + // GetSatEnthalpy and GetSatPressure are made.) - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } - RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { + int RefrigNum = 0; + if (state.dataFluidProperties->NumOfRefrigerants == 0) { ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); } // Find which refrigerant (index) is being requested and then determine @@ -6691,10 +6781,10 @@ namespace Fluid { RefrigNum = RefrigIndex; } else { // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); + RefrigNum = GetRefrigNum(state, Refrigerant); if (RefrigNum == 0) { ReportFatalRefrigerantErrors(state, - state.dataFluid->NumOfRefrigerants, + state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, @@ -6704,26 +6794,65 @@ namespace Fluid { } RefrigIndex = RefrigNum; } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); + return state.dataFluidProperties->RefrigData(RefrigNum).getSupHeatPressure(state, Temperature, Enthalpy, CalledFrom); + } + + //***************************************************************************** + + Real64 RefrigerantData::getSupHeatTemp(EnergyPlusData &state, + Real64 const Pressure, // actual pressure given as input + Real64 const Enthalpy, // actual enthalpy given as input + Real64 TempLow, // lower bound of temperature in the iteration + Real64 TempUp, // upper bound of temperature in the iteration + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + // SUBROUTINE INFORMATION: + // AUTHOR Rongpeng Zhang + // DATE WRITTEN Jan 2016 + + // PURPOSE OF THIS SUBROUTINE: + // Performs iterations to calculate the refrigerant temperature corresponding to the given + // enthalpy and pressure. Works only in superheated region. + + // METHODOLOGY EMPLOYED: + // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. + + // Return value + Real64 ReturnValue; + + // FUNCTION PARAMETERS: + // the enthalpy calculated from the pressure found + static constexpr std::string_view routineName = "GetSupHeatTempRefrig"; + + // SUBROUTINE LOCAL VARIABLE DECLARATIONS: + Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature + Real64 EnthalpyLow; // Enthalpy value at interpolated pressure and low temperature + Real64 RefTHigh; // High Temperature Value for Ps (max in tables) + Real64 RefTSat; // Saturated temperature of the refrigerant. Used to check whether the refrigernat is in the superheat area + Real64 Temp; // Temperature of the superheated refrigerant at the given enthalpy and pressure + + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + // check temperature data range and attempt to cap if necessary - RefTHigh = refrig.PsHighTempValue; - RefTSat = GetSatTemperatureRefrig(state, Refrigerant, Pressure, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); + RefTHigh = this->PsHighTempValue; + RefTSat = this->getSatTemperature(state, Pressure, fmt::format("{}:{}", routineName, CalledFrom)); if (TempLow < RefTSat) { ShowWarningMessage(state, - format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; } if (TempUp > RefTHigh) { ShowWarningMessage(state, - format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + format("{}: Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempUp = RefTHigh; @@ -6731,8 +6860,8 @@ namespace Fluid { if (TempLow >= TempUp) { ShowWarningMessage(state, format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; @@ -6740,8 +6869,8 @@ namespace Fluid { } // check enthalpy data range and attempt to cap if necessary - EnthalpyLow = GetSupHeatEnthalpyRefrig(state, Refrigerant, TempLow, Pressure, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); - EnthalpyHigh = GetSupHeatEnthalpyRefrig(state, Refrigerant, TempUp, Pressure, RefrigNum, fmt::format("{}{}", RoutineNameNoSpace, CalledFrom)); + EnthalpyLow = this->getSupHeatEnthalpy(state, TempLow, Pressure, fmt::format("{}:{}", routineName, CalledFrom)); + EnthalpyHigh = this->getSupHeatEnthalpy(state, TempUp, Pressure, fmt::format("{}:{}", routineName, CalledFrom)); if (Enthalpy <= EnthalpyLow) { ReturnValue = TempLow; return ReturnValue; @@ -6757,13 +6886,11 @@ namespace Fluid { int constexpr MaxIte(500); // maximum number of iterations int SolFla; // Flag of RegulaFalsi solver - auto f = [&state, RefrigNum, Enthalpy, Pressure](Real64 Temp) { - static constexpr std::string_view RoutineNameNoSpace("GetSupHeatTempRefrigResidual"); + auto f = [&state, this, Enthalpy, Pressure](Real64 Temp) { + static constexpr std::string_view routineName = "GetSupHeatTempRefrigResidual"; Real64 Enthalpy_Req = Enthalpy; - std::string const &Refrigerant = state.dataFluid->RefrigErrorTracking(RefrigNum).Name; if (std::abs(Enthalpy_Req) < 100.0) Enthalpy_Req = sign(100.0, Enthalpy_Req); - int nonConstRefrigNum = RefrigNum; - Real64 Enthalpy_Act = GetSupHeatEnthalpyRefrig(state, Refrigerant, Temp, Pressure, nonConstRefrigNum, RoutineNameNoSpace); + Real64 Enthalpy_Act = this->getSupHeatEnthalpy(state, Temp, Pressure, routineName); return (Enthalpy_Act - Enthalpy_Req) / Enthalpy_Req; }; @@ -6774,14 +6901,67 @@ namespace Fluid { return ReturnValue; } + Real64 GetSupHeatTempRefrig(EnergyPlusData &state, + std::string_view const Refrigerant, // carries in substance name + Real64 const Pressure, // actual pressure given as input + Real64 const Enthalpy, // actual enthalpy given as input + Real64 TempLow, // lower bound of temperature in the iteration + Real64 TempUp, // upper bound of temperature in the iteration + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + // SUBROUTINE INFORMATION: + // AUTHOR Rongpeng Zhang + // DATE WRITTEN Jan 2016 + + // PURPOSE OF THIS SUBROUTINE: + // Performs iterations to calculate the refrigerant temperature corresponding to the given + // enthalpy and pressure. Works only in superheated region. + + // METHODOLOGY EMPLOYED: + // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. + + if (state.dataFluidProperties->GetInput) { + GetFluidPropertiesData(state); + state.dataFluidProperties->GetInput = false; + } + + int RefrigNum = 0; + if (state.dataFluidProperties->NumOfRefrigerants == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); + } + + // Find which refrigerant (index) is being requested and then determine + // where the temperature is within the temperature array + if (RefrigIndex > 0) { + RefrigNum = RefrigIndex; + } else { + // Find which refrigerant (index) is being requested + RefrigNum = GetRefrigNum(state, Refrigerant); + if (RefrigNum == 0) { + ReportFatalRefrigerantErrors(state, + state.dataFluidProperties->NumOfRefrigerants, + RefrigNum, + true, + Refrigerant, + "GetSupHeatPressureRefrig", + "properties", + CalledFrom); + } + RefrigIndex = RefrigNum; + } + + return state.dataFluidProperties->RefrigData(RefrigNum).getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); + } + //***************************************************************************** - Real64 GetSupHeatDensityRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 RefrigerantData::getSupHeatDensity(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -6811,56 +6991,26 @@ namespace Fluid { Real64 ReturnValue; // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetSupHeatDensityRefrig"); + static constexpr std::string_view routineName = "RefrigerantData::getSupHeatDensity"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 TempInterpRatio; // Interpolation ratio w.r.t temperature Real64 PressInterpRatio; // Interpolation ratio w.r.t pressures - Real64 DensityHigh; // Density value at interpolated pressure and high temperature - Real64 DensityLow; // Density value at interpolated pressure and low temperature int HiTempIndex; // high temperature index value int HiPressIndex; // high pressure index value - // see if data is there - if (state.dataFluid->GetInput) { - GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; - } - - int RefrigNum = 0; - if (state.dataFluid->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); - } - // initialize for this call error counters and dummy string int ErrCount = 0; int CurTempRangeErrCount = 0; int CurPresRangeErrCount = 0; - // Find which refrigerant (index) is being requested and then determine - // where the temperature and pressure are within the temperature and - // pressure arrays, respectively - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = FindRefrigerant(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluid->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); - } - RefrigIndex = RefrigNum; - } - auto const &refrig(state.dataFluid->RefrigData(RefrigNum)); - // check temperature data range and attempt to cap if necessary // low index value of Temperature from table - int TempIndex = FindArrayIndex(Temperature, refrig.SHTemps, 1, refrig.NumSuperTempPts); - if ((TempIndex > 0) && (TempIndex < refrig.NumSuperTempPts)) { // in range + int TempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); + if ((TempIndex > 0) && (TempIndex < this->NumSuperTempPts)) { // in range HiTempIndex = TempIndex + 1; - TempInterpRatio = (Temperature - refrig.SHTemps(TempIndex)) / (refrig.SHTemps(HiTempIndex) - refrig.SHTemps(TempIndex)); + TempInterpRatio = (Temperature - this->SHTemps(TempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(TempIndex)); } else if (TempIndex < 1) { ++CurTempRangeErrCount; ++ErrCount; @@ -6877,11 +7027,11 @@ namespace Fluid { } // check pressure data range and attempt to cap if necessary - int LoPressIndex = FindArrayIndex(Pressure, refrig.SHPress, 1, refrig.NumSuperPressPts); - if ((LoPressIndex > 0) && (LoPressIndex < refrig.NumSuperPressPts)) { // in range + int LoPressIndex = FindArrayIndex(Pressure, this->SHPress, 1, this->NumSuperPressPts); + if ((LoPressIndex > 0) && (LoPressIndex < this->NumSuperPressPts)) { // in range HiPressIndex = LoPressIndex + 1; - Real64 const SHPress_Lo(refrig.SHPress(LoPressIndex)); - PressInterpRatio = (Pressure - SHPress_Lo) / (refrig.SHPress(HiPressIndex) - SHPress_Lo); + Real64 const SHPress_Lo = this->SHPress(LoPressIndex); + PressInterpRatio = (Pressure - SHPress_Lo) / (this->SHPress(HiPressIndex) - SHPress_Lo); } else if (LoPressIndex < 1) { ++CurPresRangeErrCount; ++ErrCount; @@ -6897,18 +7047,17 @@ namespace Fluid { } // get interpolation point values - auto const &Rhosh(refrig.RhoshValues); - Real64 LoTempLoDensity = Rhosh(LoPressIndex, TempIndex); - Real64 LoTempHiDensity = Rhosh(HiPressIndex, TempIndex); - Real64 HiTempLoDensity = Rhosh(LoPressIndex, HiTempIndex); - Real64 HiTempHiDensity = Rhosh(HiPressIndex, HiTempIndex); + Real64 LoTempLoDensity = this->RhoshValues(LoPressIndex, TempIndex); + Real64 LoTempHiDensity = this->RhoshValues(HiPressIndex, TempIndex); + Real64 HiTempLoDensity = this->RhoshValues(LoPressIndex, HiTempIndex); + Real64 HiTempHiDensity = this->RhoshValues(HiPressIndex, HiTempIndex); // to give reasonable interpolation near saturation reset any point with zero value // in table to saturation value int n_zero(0); Real64 saturated_density(0.0); if (min(LoTempLoDensity, LoTempHiDensity, HiTempLoDensity, HiTempHiDensity) <= 0.0) { - saturated_density = GetSatDensityRefrig(state, Refrigerant, Temperature, 1.0, RefrigNum, RoutineName); + saturated_density = this->getSatDensity(state, Temperature, 1.0, routineName); if (LoTempLoDensity <= 0.0) { LoTempLoDensity = saturated_density; ++n_zero; @@ -6929,34 +7078,34 @@ namespace Fluid { if (n_zero < 4) { // interpolate w.r.t. pressure - DensityLow = PressInterpRatio * LoTempHiDensity + (1.0 - PressInterpRatio) * LoTempLoDensity; - DensityHigh = PressInterpRatio * HiTempHiDensity + (1.0 - PressInterpRatio) * HiTempLoDensity; + Real64 DensityLow = PressInterpRatio * LoTempHiDensity + (1.0 - PressInterpRatio) * LoTempLoDensity; + Real64 DensityHigh = PressInterpRatio * HiTempHiDensity + (1.0 - PressInterpRatio) * HiTempLoDensity; // interpolate w.r.t. temperature ReturnValue = TempInterpRatio * DensityHigh + (1.0 - TempInterpRatio) * DensityLow; } else { // All data is at zero: we are completely inside the saturation dome. Best thing we can do is return saturation value - ++state.dataFluid->SatErrCountGetSupHeatDensityRefrig; + + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + ++state.dataFluidProperties->SatErrCountGetSupHeatDensityRefrig; // send warning - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount += state.dataFluid->SatErrCountGetSupHeatDensityRefrig; + refrigError.SatSupDensityErrCount += state.dataFluidProperties->SatErrCountGetSupHeatDensityRefrig; // send warning - if (state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityErrCount <= state.dataFluid->RefrigerantErrorLimitTest) { + if (refrigError.SatSupDensityErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] is saturated at the given conditions, saturated density at given temperature returned. **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); ShowContinueError(state, format("Returned Density value = {:.3R}", saturated_density)); ShowContinueErrorTimeStamp(state, ""); } - if (state.dataFluid->SatErrCountGetSupHeatDensityRefrig > 0) { + if (state.dataFluidProperties->SatErrCountGetSupHeatDensityRefrig > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + ": Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] saturated at the given conditions **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupEnthalpyErrIndex, + format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, refrigError.Name), + refrigError.SatSupEnthalpyErrIndex, Temperature, Temperature, _, @@ -6970,23 +7119,21 @@ namespace Fluid { // some checks... if (ErrCount > 0) { // send temp range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + auto &refrigError = state.dataFluidProperties->RefrigErrorTracking(this->Num); + refrigError.SatSupDensityTempErrCount += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && refrigError.SatSupDensityTempErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + ": Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Temperature is out of range for superheated refrigerant density: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityTempErrIndex, + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", routineName, refrigError.Name), + refrigError.SatSupDensityTempErrIndex, Temperature, Temperature, _, @@ -6995,22 +7142,19 @@ namespace Fluid { } // send pressure range error if flagged - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrCount <= - state.dataFluid->RefrigerantErrorLimitTest) { + refrigError.SatSupDensityPresErrCount += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && refrigError.SatSupDensityPresErrCount <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", - RoutineName, - state.dataFluid->RefrigErrorTracking(RefrigNum).Name)); + routineName, + refrigError.Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + ": Refrigerant [" + - state.dataFluid->RefrigErrorTracking(RefrigNum).Name + - "] Pressure is out of range for superheated refrigerant density: values capped **", - state.dataFluid->RefrigErrorTracking(RefrigNum).SatSupDensityPresErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", routineName, refrigError.Name), + refrigError.SatSupDensityPresErrIndex, Pressure, Pressure, _, @@ -7023,18 +7167,80 @@ namespace Fluid { return ReturnValue; } + Real64 GetSupHeatDensityRefrig(EnergyPlusData &state, + std::string_view const Refrigerant, // carries in substance name + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // SUBROUTINE INFORMATION: + // AUTHOR Mike Turner + // DATE WRITTEN 10 December 99 + // MODIFIED Rick Strand (April 2000, May 2000) + // MODIFIED Simon Rees (May 2002) + + // PURPOSE OF THIS SUBROUTINE: + // Performs linear interpolation between pressures and temperatures and + // returns Density values. Works only in superheated region. + + // METHODOLOGY EMPLOYED: + // Double linear interpolation is used with Density values at four + // pressure/temperature input points surrounding the given temperature + // and pressure arguments. + // With Density data it is assumed that zero values in the data are in + // the saturated region. Hence, values near the saturation line are + // approximated using the saturation value instead of the zero data value. + // points completely in the saturation region are given the saturation value + // at the given temperature. Points at the upper limits of pressure/temperature + // have the pressure/temperature capped. Warnings are given if the point + // is not clearly in the bounds of the superheated data. + + // FUNCTION PARAMETERS: + static constexpr std::string_view RoutineName("GetSupHeatDensityRefrig"); + + // see if data is there + if (state.dataFluidProperties->GetInput) { + GetFluidPropertiesData(state); + state.dataFluidProperties->GetInput = false; + } + + int RefrigNum = 0; + if (state.dataFluidProperties->NumOfRefrigerants == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + } + + // Find which refrigerant (index) is being requested and then determine + // where the temperature and pressure are within the temperature and + // pressure arrays, respectively + if (RefrigIndex > 0) { + RefrigNum = RefrigIndex; + } else { + // Find which refrigerant (index) is being requested + RefrigNum = GetRefrigNum(state, Refrigerant); + if (RefrigNum == 0) { + ReportFatalRefrigerantErrors( + state, state.dataFluidProperties->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + } + RefrigIndex = RefrigNum; + } + + return state.dataFluidProperties->RefrigData(RefrigNum).getSupHeatDensity(state, Temperature, Pressure, CalledFrom); + } + //***************************************************************************** #ifdef EP_cache_GlycolSpecificHeat - Real64 GetSpecificHeatGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GlycolData::getSpecificHeat(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { std::uint64_t constexpr Grid_Shift = 64 - 12 - t_sh_precision_bits; - double const t(Temperature + 1000 * GlycolIndex); + double const t(Temperature + 1000 * this->Num); DISABLE_WARNING_PUSH DISABLE_WARNING_STRICT_ALIASING @@ -7044,28 +7250,24 @@ namespace Fluid { DISABLE_WARNING_POP std::uint64_t const hash(T_tag & t_sh_cache_mask); - auto &cTsh(state.dataFluid->cached_t_sh[hash]); + auto &cTsh(state.dataFluidProperties->cached_t_sh[hash]); if (cTsh.iT != T_tag) { cTsh.iT = T_tag; - cTsh.sh = GetSpecificHeatGlycol_raw(state, Glycol, Temperature, GlycolIndex, CalledFrom); + cTsh.sh = this->getSpecificHeat_raw(state, Temperature, CalledFrom); } return cTsh.sh; // saturation pressure {Pascals} } - Real64 GetSpecificHeatGlycol_raw(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GlycolData::getSpecificHeat_raw(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) #else - Real64 GetSpecificHeatGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GlycolData::getSpecificHeat(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) #endif { @@ -7084,108 +7286,81 @@ namespace Fluid { // Warnings are given if the point is not clearly in the bounds of the // glycol data. The value returned is the appropriate limit value. - // REFERENCES: - // GetFluidPropertiesData: subroutine enforces that temperatures in - // all temperature lists are entered in ascending order. - - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetSpecificHeatGlycol: "); - - // Get the input if we haven't already - if (state.dataFluid->GetInput) { - GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; - } - - // If no glycols, no fluid properties can be evaluated - int GlycolNum(0); - if (state.dataFluid->NumOfGlycols == 0) - ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); - - // If glycol index has not yet been found for this fluid, find its value now - if (GlycolIndex > 0) { - GlycolNum = GlycolIndex; - } else { // Find which glycol (index) is being requested - GlycolNum = FindGlycol(state, Glycol); - if (GlycolNum == 0) { - ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); - } - GlycolIndex = GlycolNum; - } - auto const &glycol_data(state.dataFluid->GlycolData(GlycolIndex)); - + // REFERENCES: + // GetFluidPropertiesData: subroutine enforces that temperatures in + // all temperature lists are entered in ascending order. + + // FUNCTION PARAMETERS: + static constexpr std::string_view routineName = "GlycolData::getSpecificHeat"; + + auto &glycolError = state.dataFluidProperties->GlycolErrorTracking(this->Num); + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!glycol_data.CpDataPresent) { + if (!this->CpDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluid->NumOfGlycols, - GlycolNum, - glycol_data.CpDataPresent, - Glycol, + state.dataFluidProperties->NumOfGlycols, + this->Num, + this->CpDataPresent, + this->Name, "GetSpecificHeatGlycol", "specific heat", CalledFrom); } // Now determine the value of specific heat using interpolation - if (Temperature < glycol_data.CpLowTempValue) { // Temperature too low + if (Temperature < this->CpLowTempValue) { // Temperature too low if (!state.dataGlobal->WarmupFlag) { - state.dataFluid->LowTempLimitErrGetSpecificHeatGlycol_raw = - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrCount; - if (state.dataFluid->LowTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluid->GlycolErrorLimitTest) { + state.dataFluidProperties->LowTempLimitErrGetSpecificHeatGlycol_raw = ++glycolError.SpecHeatLowErrCount; + if (state.dataFluidProperties->LowTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProperties->GlycolErrorLimitTest) { ShowWarningMessage(state, - format("{}Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", - RoutineName, - glycol_data.Name)); + format("{}: Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", + routineName, + this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - glycol_data.CpLowTempValue, - glycol_data.CpHighTempValue)); + this->CpLowTempValue, + this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + glycol_data.Name + - "] specific heat **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatLowErrIndex, + format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), + glycolError.SpecHeatLowErrIndex, Temperature, Temperature, _, "{C}", "{C}"); } - return glycol_data.CpValues(glycol_data.CpLowTempIndex); - } else if (Temperature > glycol_data.CpHighTempValue) { // Temperature too high + return this->CpValues(this->CpLowTempIndex); + + } else if (Temperature > this->CpHighTempValue) { // Temperature too high if (!state.dataGlobal->WarmupFlag) { - state.dataFluid->HighTempLimitErrGetSpecificHeatGlycol_raw = - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrCount; - if (state.dataFluid->HighTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluid->GlycolErrorLimitTest) { + state.dataFluidProperties->HighTempLimitErrGetSpecificHeatGlycol_raw = ++glycolError.SpecHeatHighErrCount; + if (state.dataFluidProperties->HighTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProperties->GlycolErrorLimitTest) { ShowWarningMessage( - state, format("{}Temperature is out of range (too high) for fluid [{}] specific heat **", RoutineName, glycol_data.Name)); + state, format("{}: Temperature is out of range (too high) for fluid [{}] specific heat **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - glycol_data.CpLowTempValue, - glycol_data.CpHighTempValue)); + this->CpLowTempValue, + this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + glycol_data.Name + - "] specific heat **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).SpecHeatHighErrIndex, + format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), + glycolError.SpecHeatHighErrIndex, Temperature, Temperature, _, "{C}", "{C}"); } - return glycol_data.CpValues(glycol_data.CpHighTempIndex); + return this->CpValues(this->CpHighTempIndex); + } else { // Temperature somewhere between the lowest and highest value - auto const &glycol_CpTemps(glycol_data.CpTemps); - auto const &glycol_CpValues(glycol_data.CpValues); // bracket is temp > low, <= high (for interpolation // for ( int Loop = glycol_data.CpLowTempIndex + 1; Loop <= glycol_data.CpHighTempIndex; ++Loop ) { //Tuned Replaced by binary search // below if ( Temperature > glycol_data.CpTemps( Loop ) ) continue; return GetInterpValue( Temperature, glycol_CpTemps( Loop - 1 @@ -7193,25 +7368,23 @@ namespace Fluid { //} // assert( std::is_sorted( glycol_CpTemps.begin(), glycol_CpTemps.end() ) ); // Sorted temperature array is assumed: Enable if/when arrays // have begin()/end() - assert(glycol_CpTemps.size() <= + assert(this->CpTemps.size() <= static_cast(std::numeric_limits::max())); // Array indexes are int now so this is future protection - int beg(1), end(glycol_CpTemps.isize()); // 1-based indexing + int beg(1), end(this->CpTemps.isize()); // 1-based indexing assert(end > 0); while (beg + 1 < end) { int mid = ((beg + end) >> 1); // bit shifting is faster than /2 - (Temperature > glycol_CpTemps(mid) ? beg : end) = mid; + (Temperature > this->CpTemps(mid) ? beg : end) = mid; } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] - return GetInterpValue_fast(Temperature, glycol_CpTemps(beg), glycol_CpTemps(end), glycol_CpValues(beg), glycol_CpValues(end)); + return GetInterpValue_fast(Temperature, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); } } - //***************************************************************************** - - Real64 GetDensityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GetSpecificHeatGlycol(EnergyPlusData &state, + std::string_view const Glycol, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -7220,11 +7393,11 @@ namespace Fluid { // DATE WRITTEN June 2004 // PURPOSE OF THIS FUNCTION: - // This subroutine finds the density for glycols at different + // This subroutine finds specific heats for glycols at different // temperatures. // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find density values for a + // Linear interpolation is used to find specific heat values for a // particular glycol (water or some mixture of water and another fluid). // Warnings are given if the point is not clearly in the bounds of the // glycol data. The value returned is the appropriate limit value. @@ -7233,105 +7406,123 @@ namespace Fluid { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetDensityGlycol: "); - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluid->NumOfGlycols == 0) - ReportFatalGlycolErrors(state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); + if (state.dataFluidProperties->NumOfGlycols == 0) + ReportFatalGlycolErrors( + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { GlycolNum = GlycolIndex; - } else { // Find which refrigerant (index) is being requested - GlycolNum = FindGlycol(state, Glycol); + } else { // Find which glycol (index) is being requested + GlycolNum = GetGlycolNum(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); } GlycolIndex = GlycolNum; } + return state.dataFluidProperties->GlycolData(GlycolIndex).getSpecificHeat(state, Temperature, CalledFrom); + } + + //***************************************************************************** + + Real64 GlycolData::getDensity(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // FUNCTION INFORMATION: + // AUTHOR Rick Strand + // DATE WRITTEN June 2004 + + // PURPOSE OF THIS FUNCTION: + // This subroutine finds the density for glycols at different + // temperatures. + + // METHODOLOGY EMPLOYED: + // Linear interpolation is used to find density values for a + // particular glycol (water or some mixture of water and another fluid). + // Warnings are given if the point is not clearly in the bounds of the + // glycol data. The value returned is the appropriate limit value. + + // REFERENCES: + // GetFluidPropertiesData: subroutine enforces that temperatures in + // all temperature lists are entered in ascending order. + + // Return value + Real64 ReturnValue; + + // FUNCTION PARAMETERS: + static constexpr std::string_view routineName = "GetDensityGlycol"; + + // FUNCTION LOCAL VARIABLE DECLARATIONS: + bool LowErrorThisTime = false; + bool HighErrorThisTime = false; + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluid->GlycolData(GlycolIndex).RhoDataPresent) { + if (!this->RhoDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluid->NumOfGlycols, - GlycolNum, - state.dataFluid->GlycolData(GlycolIndex).RhoDataPresent, - Glycol, + state.dataFluidProperties->NumOfGlycols, + this->Num, + this->RhoDataPresent, + this->Name, "GetDensityGlycol", "density", CalledFrom); } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue) { // Temperature too low + if (Temperature < this->RhoLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex); - } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue) { // Temperature too high + ReturnValue = this->RhoValues(this->RhoLowTempIndex); + } else if (Temperature > this->RhoHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoHighTempIndex); + ReturnValue = this->RhoValues(this->RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).RhoValues(state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex); - // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluid->GlycolData(GlycolIndex).RhoLowTempIndex + 1; - Loop <= state.dataFluid->GlycolData(GlycolIndex).RhoHighTempIndex; - ++Loop) { - if (Temperature > state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop)) continue; - ReturnValue = GetInterpValue(state, - Temperature, - state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).RhoTemps(Loop), - state.dataFluid->GlycolData(GlycolIndex).RhoValues(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).RhoValues(Loop)); - break; // DO loop - } + int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPts); + Real64 TempInterpRatio = (Temperature - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); + ReturnValue = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); } // Error handling if (!state.dataGlobal->WarmupFlag) { - + auto &glycolError = state.dataFluidProperties->GlycolErrorTracking(this->Num); if (LowErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; - state.dataFluid->LowTempLimitErrGetDensityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrCount; + ++glycolError.DensityLowErrCount; + state.dataFluidProperties->LowTempLimitErrGetDensityGlycol = glycolError.DensityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; - state.dataFluid->HighTempLimitErrGetDensityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrCount; + ++glycolError.DensityHighErrCount; + state.dataFluidProperties->HighTempLimitErrGetDensityGlycol = glycolError.DensityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetDensityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluidProperties->LowTempLimitErrGetDensityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too low) for fluid [{}] density **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + routineName, + this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue)); + this->RhoLowTempValue, + this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] density **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityLowErrIndex, + format("{}: Temperature out of range (too low) for fluid [{}] density **", routineName, this->Name), + glycolError.DensityLowErrIndex, Temperature, Temperature, _, @@ -7339,24 +7530,23 @@ namespace Fluid { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetDensityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluidProperties->HighTempLimitErrGetDensityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, - format("{}Temperature is out of range (too high) for fluid [{}] density **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + format("{}: Temperature is out of range (too high) for fluid [{}] density **", + routineName, + this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).RhoLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).RhoHighTempValue)); + this->RhoLowTempValue, + this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] density **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).DensityHighErrIndex, + format("{}: Temperature out of range (too high) for fluid [{}] density **", routineName, this->Name), + glycolError.DensityHighErrIndex, Temperature, Temperature, _, @@ -7368,13 +7558,11 @@ namespace Fluid { return ReturnValue; } - //***************************************************************************** - - Real64 GetConductivityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GetDensityGlycol(EnergyPlusData &state, + std::string_view const Glycol, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -7383,11 +7571,11 @@ namespace Fluid { // DATE WRITTEN June 2004 // PURPOSE OF THIS FUNCTION: - // This subroutine finds the conductivity for glycols at different + // This subroutine finds the density for glycols at different // temperatures. // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find conductivity values for a + // Linear interpolation is used to find density values for a // particular glycol (water or some mixture of water and another fluid). // Warnings are given if the point is not clearly in the bounds of the // glycol data. The value returned is the appropriate limit value. @@ -7396,108 +7584,122 @@ namespace Fluid { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetConductivityGlycol: "); - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluid->NumOfGlycols == 0) - ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); + if (state.dataFluidProperties->NumOfGlycols == 0) + ReportFatalGlycolErrors(state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { GlycolNum = GlycolIndex; } else { // Find which refrigerant (index) is being requested - GlycolNum = FindGlycol(state, Glycol); + GlycolNum = GetGlycolNum(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); } GlycolIndex = GlycolNum; } + return state.dataFluidProperties->GlycolData(GlycolIndex).getDensity(state, Temperature, CalledFrom); + } + + //***************************************************************************** + + Real64 GlycolData::getConductivity(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // FUNCTION INFORMATION: + // AUTHOR Rick Strand + // DATE WRITTEN June 2004 + + // PURPOSE OF THIS FUNCTION: + // This subroutine finds the conductivity for glycols at different + // temperatures. + + // METHODOLOGY EMPLOYED: + // Linear interpolation is used to find conductivity values for a + // particular glycol (water or some mixture of water and another fluid). + // Warnings are given if the point is not clearly in the bounds of the + // glycol data. The value returned is the appropriate limit value. + + // REFERENCES: + // GetFluidPropertiesData: subroutine enforces that temperatures in + // all temperature lists are entered in ascending order. + + // Return value + Real64 ReturnValue; + + // FUNCTION PARAMETERS: + static constexpr std::string_view routineName = "GlycolData::getConductivity"; + + // FUNCTION LOCAL VARIABLE DECLARATIONS: + bool LowErrorThisTime = false; + bool HighErrorThisTime = false; + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluid->GlycolData(GlycolIndex).CondDataPresent) { + if (!this->CondDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluid->NumOfGlycols, - GlycolNum, - state.dataFluid->GlycolData(GlycolIndex).CondDataPresent, - Glycol, + state.dataFluidProperties->NumOfGlycols, + this->Num, + this->CondDataPresent, + this->Name, "GetConductivityGlycol", "conductivity", CalledFrom); } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue) { // Temperature too low + if (Temperature < this->CondLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex); - } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue) { // Temperature too high + ReturnValue = this->CondValues(this->CondLowTempIndex); + } else if (Temperature > this->CondHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondHighTempIndex); + ReturnValue = this->CondValues(this->CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).CondValues(state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex); - // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluid->GlycolData(GlycolIndex).CondLowTempIndex + 1; - Loop <= state.dataFluid->GlycolData(GlycolIndex).CondHighTempIndex; - ++Loop) { - if (Temperature > state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop)) continue; - ReturnValue = GetInterpValue(state, - Temperature, - state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).CondTemps(Loop), - state.dataFluid->GlycolData(GlycolIndex).CondValues(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).CondValues(Loop)); - break; // DO loop - } + int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPts); + Real64 TempInterpRatio = (Temperature - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); + ReturnValue = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); } // Error handling if (!state.dataGlobal->WarmupFlag) { - + auto &glycolError = state.dataFluidProperties->GlycolErrorTracking(this->Num); if (LowErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; - state.dataFluid->LowTempLimitErrGetConductivityGlycol = - state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrCount; + ++glycolError.ConductivityLowErrCount; + state.dataFluidProperties->LowTempLimitErrGetConductivityGlycol = glycolError.ConductivityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; - state.dataFluid->HighTempLimitErrGetConductivityGlycol = - state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrCount; + ++glycolError.ConductivityHighErrCount; + state.dataFluidProperties->HighTempLimitErrGetConductivityGlycol = glycolError.ConductivityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetConductivityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluidProperties->LowTempLimitErrGetConductivityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, - format("{}Temperature is out of range (too low) for fluid [{}] conductivity **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + format("{}: Temperature is out of range (too low) for fluid [{}] conductivity **", + routineName, + this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue)); + this->CondLowTempValue, + this->CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] conductivity **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityLowErrIndex, + format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), + glycolError.ConductivityLowErrIndex, Temperature, Temperature, _, @@ -7505,24 +7707,23 @@ namespace Fluid { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetConductivityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluidProperties->HighTempLimitErrGetConductivityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, - format("{}Temperature is out of range (too high) for fluid [{}] conductivity **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + format("{}: Temperature is out of range (too high) for fluid [{}] conductivity **", + routineName, + this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).CondLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).CondHighTempValue)); + this->CondLowTempValue, + this->CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] conductivity **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).ConductivityHighErrIndex, + format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), + glycolError.ConductivityHighErrIndex, Temperature, Temperature, _, @@ -7534,13 +7735,11 @@ namespace Fluid { return ReturnValue; } - //***************************************************************************** - - Real64 GetViscosityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 GetConductivityGlycol(EnergyPlusData &state, + std::string_view const Glycol, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -7549,11 +7748,11 @@ namespace Fluid { // DATE WRITTEN June 2004 // PURPOSE OF THIS FUNCTION: - // This subroutine finds the viscosity for glycols at different + // This subroutine finds the conductivity for glycols at different // temperatures. // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find viscosity values for a + // Linear interpolation is used to find conductivity values for a // particular glycol (water or some mixture of water and another fluid). // Warnings are given if the point is not clearly in the bounds of the // glycol data. The value returned is the appropriate limit value. @@ -7562,107 +7761,124 @@ namespace Fluid { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // Return value - Real64 ReturnValue; // Value for function - - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetViscosityGlycol: "); - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - // Get the input if we haven't already - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // If no glycols, no fluid properties can be evaluated int GlycolNum = 0; - if (state.dataFluid->NumOfGlycols == 0) + if (state.dataFluidProperties->NumOfGlycols == 0) ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); // If glycol index has not yet been found for this fluid, find its value now if (GlycolIndex > 0) { GlycolNum = GlycolIndex; } else { // Find which refrigerant (index) is being requested - GlycolNum = FindGlycol(state, Glycol); + GlycolNum = GetGlycolNum(state, Glycol); if (GlycolNum == 0) { ReportFatalGlycolErrors( - state, state.dataFluid->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); } GlycolIndex = GlycolNum; } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!state.dataFluid->GlycolData(GlycolIndex).ViscDataPresent) { + return state.dataFluidProperties->GlycolData(GlycolIndex).getConductivity(state, Temperature, CalledFrom); + } + + //***************************************************************************** + + Real64 GlycolData::getViscosity(EnergyPlusData &state, + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // FUNCTION INFORMATION: + // AUTHOR Rick Strand + // DATE WRITTEN June 2004 + + // PURPOSE OF THIS FUNCTION: + // This subroutine finds the viscosity for glycols at different + // temperatures. + + // METHODOLOGY EMPLOYED: + // Linear interpolation is used to find viscosity values for a + // particular glycol (water or some mixture of water and another fluid). + // Warnings are given if the point is not clearly in the bounds of the + // glycol data. The value returned is the appropriate limit value. + + // REFERENCES: + // GetFluidPropertiesData: subroutine enforces that temperatures in + // all temperature lists are entered in ascending order. + + // Return value + Real64 ReturnValue; // Value for function + + // FUNCTION PARAMETERS: + static constexpr std::string_view routineName = "GlycolData::getViscosity"; + + // FUNCTION LOCAL VARIABLE DECLARATIONS: + bool LowErrorThisTime = false; + bool HighErrorThisTime = false; + + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value + if (!this->ViscDataPresent) { ReportFatalGlycolErrors(state, - state.dataFluid->NumOfGlycols, - GlycolNum, - state.dataFluid->GlycolData(GlycolIndex).ViscDataPresent, - Glycol, + state.dataFluidProperties->NumOfGlycols, + this->Num, + this->ViscDataPresent, + this->Name, "GetViscosityGlycol", "viscosity", CalledFrom); } // Now determine the value of specific heat using interpolation - if (Temperature < state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue) { // Temperature too low + if (Temperature < this->ViscLowTempValue) { // Temperature too low LowErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex); - } else if (Temperature > state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue) { // Temperature too high + ReturnValue = this->ViscValues(this->ViscLowTempIndex); + } else if (Temperature > this->ViscHighTempValue) { // Temperature too high HighErrorThisTime = true; - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscHighTempIndex); + ReturnValue = this->ViscValues(this->ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - ReturnValue = state.dataFluid->GlycolData(GlycolIndex).ViscValues(state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex); - // bracket is temp > low, <= high (for interpolation - for (int Loop = state.dataFluid->GlycolData(GlycolIndex).ViscLowTempIndex + 1; - Loop <= state.dataFluid->GlycolData(GlycolIndex).ViscHighTempIndex; - ++Loop) { - if (Temperature > state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop)) continue; - ReturnValue = GetInterpValue(state, - Temperature, - state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).ViscTemps(Loop), - state.dataFluid->GlycolData(GlycolIndex).ViscValues(Loop - 1), - state.dataFluid->GlycolData(GlycolIndex).ViscValues(Loop)); - break; // DO loop - } + int LoTempIndex = FindArrayIndex(Temperature, this->ViscTemps, 1, this->NumViscTempPts); + Real64 TempInterpRatio = (Temperature - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); + ReturnValue = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); } // Error handling if (!state.dataGlobal->WarmupFlag) { - + auto &glycolError = state.dataFluidProperties->GlycolErrorTracking(this->Num); if (LowErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; - state.dataFluid->LowTempLimitErrGetViscosityGlycol = state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrCount; + ++glycolError.ViscosityLowErrCount; + state.dataFluidProperties->LowTempLimitErrGetViscosityGlycol = glycolError.ViscosityLowErrCount; } if (HighErrorThisTime) { - ++state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; - state.dataFluid->HighTempLimitErrGetViscosityGlycol = - state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrCount; + ++glycolError.ViscosityHighErrCount; + state.dataFluidProperties->HighTempLimitErrGetViscosityGlycol = glycolError.ViscosityHighErrCount; } - if ((LowErrorThisTime) && (state.dataFluid->LowTempLimitErrGetViscosityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((LowErrorThisTime) && (state.dataFluidProperties->LowTempLimitErrGetViscosityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, - format("{}Temperature is out of range (too low) for fluid [{}] viscosity **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + format("{}: Temperature is out of range (too low) for fluid [{}] viscosity **", + routineName, + glycolError.Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue)); + this->ViscLowTempValue, + this->ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too low) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] viscosity **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityLowErrIndex, + format("{}: Temperature out of range (too low) for fluid [{}] viscosity **", routineName, glycolError.Name), + glycolError.ViscosityLowErrIndex, Temperature, Temperature, _, @@ -7670,24 +7886,23 @@ namespace Fluid { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluid->HighTempLimitErrGetViscosityGlycol <= state.dataFluid->GlycolErrorLimitTest)) { + if ((HighErrorThisTime) && (state.dataFluidProperties->HighTempLimitErrGetViscosityGlycol <= state.dataFluidProperties->GlycolErrorLimitTest)) { ShowWarningMessage(state, format("{}Temperature is out of range (too high) for fluid [{}] viscosity **", - RoutineName, - state.dataFluid->GlycolData(GlycolIndex).Name)); + routineName, + glycolError.Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, Temperature, - state.dataFluid->GlycolData(GlycolIndex).ViscLowTempValue, - state.dataFluid->GlycolData(GlycolIndex).ViscHighTempValue)); + this->ViscLowTempValue, + this->ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - std::string{RoutineName} + "Temperature out of range (too high) for fluid [" + - state.dataFluid->GlycolData(GlycolIndex).Name + "] viscosity **", - state.dataFluid->GlycolErrorTracking(GlycolIndex).ViscosityHighErrIndex, + format("{}: Temperature out of range (too high) for fluid [{}] viscosity **", routineName, glycolError.Name), + glycolError.ViscosityHighErrIndex, Temperature, Temperature, _, @@ -7699,6 +7914,60 @@ namespace Fluid { return ReturnValue; } + Real64 GetViscosityGlycol(EnergyPlusData &state, + std::string_view const Glycol, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) + ) + { + + // FUNCTION INFORMATION: + // AUTHOR Rick Strand + // DATE WRITTEN June 2004 + + // PURPOSE OF THIS FUNCTION: + // This subroutine finds the viscosity for glycols at different + // temperatures. + + // METHODOLOGY EMPLOYED: + // Linear interpolation is used to find viscosity values for a + // particular glycol (water or some mixture of water and another fluid). + // Warnings are given if the point is not clearly in the bounds of the + // glycol data. The value returned is the appropriate limit value. + + // REFERENCES: + // GetFluidPropertiesData: subroutine enforces that temperatures in + // all temperature lists are entered in ascending order. + + // Get the input if we haven't already + if (state.dataFluidProperties->GetInput) { + GetFluidPropertiesData(state); + state.dataFluidProperties->GetInput = false; + } + + // If no glycols, no fluid properties can be evaluated + int GlycolNum = 0; + if (state.dataFluidProperties->NumOfGlycols == 0) + ReportFatalGlycolErrors( + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + + // If glycol index has not yet been found for this fluid, find its value now + if (GlycolIndex > 0) { + GlycolNum = GlycolIndex; + } else { // Find which refrigerant (index) is being requested + GlycolNum = GetGlycolNum(state, Glycol); + if (GlycolNum == 0) { + ReportFatalGlycolErrors( + state, state.dataFluidProperties->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + } + GlycolIndex = GlycolNum; + } + + // Now determine the value of specific heat using interpolation + return state.dataFluidProperties->GlycolData(GlycolIndex).getViscosity(state, Temperature, CalledFrom); + } + //***************************************************************************** void GetInterpValue_error(EnergyPlusData &state) @@ -7706,7 +7975,7 @@ namespace Fluid { ShowFatalError(state, "GetInterpValue: Temperatures for fluid property data too close together, division by zero"); } - int FindRefrigerant(EnergyPlusData &state, std::string_view const Refrigerant) // carries in substance name + int GetRefrigNum(EnergyPlusData &state, std::string_view const name) // carries in substance name { // FUNCTION INFORMATION: @@ -7724,31 +7993,30 @@ namespace Fluid { // to the index within the derived type. If the input has not been read // yet for some reason, that must be done. - // Return value - int FindRefrigerant; - // Make sure we have already read in the input - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // Check to see if this glycol shows up in the glycol data - int Found = Util::FindItemInList(Util::makeUPPER(Refrigerant), state.dataFluid->RefrigData); + int refrigNum = Util::FindItemInList(Util::makeUPPER(name), state.dataFluidProperties->RefrigData); - if (Found > 0) { - FindRefrigerant = Found; - state.dataFluid->RefrigUsed(Found) = true; - } else { // not found - errors handled in calling proceedure - FindRefrigerant = 0; + if (refrigNum > 0) { + state.dataFluidProperties->RefrigUsed(refrigNum) = true; } - return FindRefrigerant; + return refrigNum; + } + + RefrigerantData *GetRefrig(EnergyPlusData &state, std::string_view const name) { + int refrigNum = GetRefrigNum(state, name); + return (refrigNum > 0) ? &state.dataFluidProperties->RefrigData(refrigNum) : nullptr; } //***************************************************************************** - int FindGlycol(EnergyPlusData &state, std::string_view const Glycol) // carries in substance name + int GetGlycolNum(EnergyPlusData &state, std::string_view const name) // carries in substance name { // FUNCTION INFORMATION: @@ -7766,28 +8034,27 @@ namespace Fluid { // to the index within the derived type. If the input has not been read // yet for some reason, that must be done. - // Return value - int FindGlycol; - // Make sure we have already read in the input - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // Check to see if this glycol shows up in the glycol data - int Found = Util::FindItemInList(Util::makeUPPER(Glycol), - state.dataFluid->GlycolData, - state.dataFluid->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs + int glycolNum = Util::FindItemInList(Util::makeUPPER(name), + state.dataFluidProperties->GlycolData, + state.dataFluidProperties->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs - if (Found > 0) { - FindGlycol = Found; - state.dataFluid->GlycolUsed(Found) = true; - } else { // return zero - error checking in calling proceedure - FindGlycol = 0; + if (glycolNum > 0) { + state.dataFluidProperties->GlycolUsed(glycolNum) = true; } - return FindGlycol; + return glycolNum; + } + + GlycolData *GetGlycol(EnergyPlusData &state, std::string_view const name) { + int glycolNum = GetGlycolNum(state, name); + return (glycolNum > 0) ? &state.dataFluidProperties->GlycolData(glycolNum) : nullptr; } //***************************************************************************** @@ -7813,8 +8080,8 @@ namespace Fluid { // Check to see if this glycol shows up in the glycol data // ArrayLength = SIZE(GlycolData) - if (Idx > 0 && Idx <= state.dataFluid->NumOfGlycols) { - return state.dataFluid->GlycolData(Idx).Name; + if (Idx > 0 && Idx <= state.dataFluidProperties->NumOfGlycols) { + return state.dataFluidProperties->GlycolData(Idx).Name; } else { // return blank - error checking in calling proceedure return ""; } @@ -7986,9 +8253,9 @@ namespace Fluid { } if (ErrorFlag && (CalledFrom != "ReportAndTestRefrigerants")) { - ++state.dataFluid->TempRangeErrCountGetInterpolatedSatProp; + ++state.dataFluidProperties->TempRangeErrCountGetInterpolatedSatProp; // send warning - if (state.dataFluid->TempRangeErrCountGetInterpolatedSatProp <= state.dataFluid->RefrigerantErrorLimitTest) { + if (state.dataFluidProperties->TempRangeErrCountGetInterpolatedSatProp <= state.dataFluidProperties->RefrigerantErrorLimitTest) { ShowWarningError(state, "GetInterpolatedSatProp: Saturation temperature for interpolation is out of range of data supplied: **"); ShowContinueErrorTimeStamp(state, fmt::format(" Called from:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); @@ -7996,7 +8263,7 @@ namespace Fluid { } else { ShowRecurringWarningErrorAtEnd(state, "GetInterpolatedSatProp: Refrigerant temperature for interpolation out of range error", - state.dataFluid->TempRangeErrIndexGetInterpolatedSatProp, + state.dataFluidProperties->TempRangeErrIndexGetInterpolatedSatProp, Temperature, Temperature, _, @@ -8024,20 +8291,20 @@ namespace Fluid { // Return value int CheckFluidPropertyName; - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } // Item must be either in Refrigerant or Glycol list int Found = 0; - if (state.dataFluid->NumOfRefrigerants > 0) { - Found = Util::FindItemInList(NameToCheck, state.dataFluid->RefrigData); + if (state.dataFluidProperties->NumOfRefrigerants > 0) { + Found = Util::FindItemInList(NameToCheck, state.dataFluidProperties->RefrigData); } if (Found == 0) { - if (state.dataFluid->NumOfGlycols > 0) { + if (state.dataFluidProperties->NumOfGlycols > 0) { Found = Util::FindItemInList( - NameToCheck, state.dataFluid->GlycolData, state.dataFluid->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs + NameToCheck, state.dataFluidProperties->GlycolData, state.dataFluidProperties->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs } } @@ -8060,16 +8327,16 @@ namespace Fluid { bool NeedOrphanMessage = true; int NumUnusedRefrig = 0; - for (int Item = 1; Item <= state.dataFluid->NumOfRefrigerants; ++Item) { - if (state.dataFluid->RefrigUsed(Item)) continue; - if (Util::SameString(state.dataFluid->RefrigData(Item).Name, Steam)) continue; + for (int Item = 1; Item <= state.dataFluidProperties->NumOfRefrigerants; ++Item) { + if (state.dataFluidProperties->RefrigUsed(Item)) continue; + if (Util::SameString(state.dataFluidProperties->RefrigData(Item).Name, Steam)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Refrigerant={}", state.dataFluid->RefrigData(Item).Name)); + ShowMessage(state, format("Refrigerant={}", state.dataFluidProperties->RefrigData(Item).Name)); } else { ++NumUnusedRefrig; } @@ -8077,18 +8344,18 @@ namespace Fluid { int NumUnusedGlycol = 0; - for (int Item = 1; Item <= state.dataFluid->NumOfGlycols; ++Item) { - if (state.dataFluid->GlycolUsed(Item)) continue; - if (Util::SameString(state.dataFluid->GlycolData(Item).Name, Water)) continue; - if (Util::SameString(state.dataFluid->GlycolData(Item).Name, EthyleneGlycol)) continue; - if (Util::SameString(state.dataFluid->GlycolData(Item).Name, PropyleneGlycol)) continue; + for (int Item = 1; Item <= state.dataFluidProperties->NumOfGlycols; ++Item) { + if (state.dataFluidProperties->GlycolUsed(Item)) continue; + if (Util::SameString(state.dataFluidProperties->GlycolData(Item).Name, Water)) continue; + if (Util::SameString(state.dataFluidProperties->GlycolData(Item).Name, EthyleneGlycol)) continue; + if (Util::SameString(state.dataFluidProperties->GlycolData(Item).Name, PropyleneGlycol)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Glycol={}", state.dataFluid->GlycolData(Item).Name)); + ShowMessage(state, format("Glycol={}", state.dataFluidProperties->GlycolData(Item).Name)); } else { ++NumUnusedGlycol; } @@ -8120,7 +8387,7 @@ namespace Fluid { // Consolidate fatal error reporting for glycols. // check and see if it might be a refrigerant - int RefrigNo = FindRefrigerant(state, GlycolName); + int RefrigNo = GetRefrigNum(state, GlycolName); if (NumGlycols == 0) { ShowSevereError( @@ -8162,7 +8429,7 @@ namespace Fluid { // Consolidate fatal error reporting for refrigerants. // check and see if it might be a refrigerant - int GlycolNo = FindGlycol(state, RefrigerantName); + int GlycolNo = GetGlycolNum(state, RefrigerantName); if (NumRefrigerants == 0) { ShowSevereError(state, @@ -8193,28 +8460,28 @@ namespace Fluid { { // Get the input if we haven't already - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } if (FluidIndex > 0) { - MinTempLimit = state.dataFluid->GlycolData(FluidIndex).RhoLowTempValue; - MaxTempLimit = state.dataFluid->GlycolData(FluidIndex).RhoHighTempValue; + MinTempLimit = state.dataFluidProperties->GlycolData(FluidIndex).RhoLowTempValue; + MaxTempLimit = state.dataFluidProperties->GlycolData(FluidIndex).RhoHighTempValue; } } void GetFluidSpecificHeatTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { // Get the input if we haven't already - if (state.dataFluid->GetInput) { + if (state.dataFluidProperties->GetInput) { GetFluidPropertiesData(state); - state.dataFluid->GetInput = false; + state.dataFluidProperties->GetInput = false; } if (FluidIndex > 0) { - MinTempLimit = state.dataFluid->GlycolData(FluidIndex).CpLowTempValue; - MaxTempLimit = state.dataFluid->GlycolData(FluidIndex).CpHighTempValue; + MinTempLimit = state.dataFluidProperties->GlycolData(FluidIndex).CpLowTempValue; + MaxTempLimit = state.dataFluidProperties->GlycolData(FluidIndex).CpHighTempValue; } } @@ -8229,19 +8496,19 @@ namespace Fluid { } Real64 GlycolAPI::specificHeat(EnergyPlusData &state, Real64 temperature) { - return Fluid::GetSpecificHeatGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return FluidProperties::GetSpecificHeatGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::density(EnergyPlusData &state, Real64 temperature) { - return Fluid::GetDensityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return FluidProperties::GetDensityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::conductivity(EnergyPlusData &state, Real64 temperature) { - return Fluid::GetConductivityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return FluidProperties::GetConductivityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } Real64 GlycolAPI::viscosity(EnergyPlusData &state, Real64 temperature) { - return Fluid::GetViscosityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); + return FluidProperties::GetViscosityGlycol(state, this->glycolName, temperature, this->glycolIndex, this->cf); } RefrigerantAPI::RefrigerantAPI(EnergyPlusData &state, std::string const &refrigName) @@ -8255,35 +8522,35 @@ namespace Fluid { } Real64 RefrigerantAPI::saturationPressure(EnergyPlusData &state, Real64 temperature) { - return Fluid::GetSatPressureRefrig(state, this->rName, temperature, this->rIndex, this->cf); + return FluidProperties::GetSatPressureRefrig(state, this->rName, temperature, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturationTemperature(EnergyPlusData &state, Real64 pressure) { - return Fluid::GetSatTemperatureRefrig(state, this->rName, pressure, this->rIndex, this->cf); + return FluidProperties::GetSatTemperatureRefrig(state, this->rName, pressure, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedEnthalpy(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return Fluid::GetSatEnthalpyRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return FluidProperties::GetSatEnthalpyRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedDensity(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return Fluid::GetSatDensityRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return FluidProperties::GetSatDensityRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::saturatedSpecificHeat(EnergyPlusData &state, Real64 temperature, Real64 quality) { - return Fluid::GetSatSpecificHeatRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); + return FluidProperties::GetSatSpecificHeatRefrig(state, this->rName, temperature, quality, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedEnthalpy(EnergyPlusData &state, Real64 temperature, Real64 pressure) { - return Fluid::GetSupHeatEnthalpyRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); + return FluidProperties::GetSupHeatEnthalpyRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedPressure(EnergyPlusData &state, Real64 temperature, Real64 enthalpy) { - return Fluid::GetSupHeatPressureRefrig(state, this->rName, temperature, enthalpy, this->rIndex, this->cf); + return FluidProperties::GetSupHeatPressureRefrig(state, this->rName, temperature, enthalpy, this->rIndex, this->cf); } Real64 RefrigerantAPI::superHeatedDensity(EnergyPlusData &state, Real64 temperature, Real64 pressure) { - return Fluid::GetSupHeatDensityRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); + return FluidProperties::GetSupHeatDensityRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); } } // namespace Fluid diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index fbb86d00dbe..3264330f5ce 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -67,7 +67,7 @@ namespace EnergyPlus { // Forward declarations struct EnergyPlusData; -namespace Fluid { +namespace FluidProperties { int constexpr EthyleneGlycolIndex = -2; int constexpr PropyleneGlycolIndex = -1; @@ -99,237 +99,277 @@ namespace Fluid { std::uint64_t constexpr t_sh_cache_mask = (t_sh_cache_size - 1); #endif - struct FluidPropsRefrigerantData + struct RefrigerantData { // Members std::string Name; // Name of the refrigerant - int NumPsPoints; // Number of saturation pressure - Real64 PsLowTempValue; // Low Temperature Value for Ps (>0.0) - Real64 PsHighTempValue; // High Temperature Value for Ps (max in tables) - int PsLowTempIndex; // Low Temperature Min Index for Ps (>0.0) - int PsHighTempIndex; // High Temperature Max Index for Ps (>0.0) - Real64 PsLowPresValue; // Low Pressure Value for Ps (>0.0) - Real64 PsHighPresValue; // High Pressure Value for Ps (max in tables) - int PsLowPresIndex; // Low Pressure Min Index for Ps (>0.0) - int PsHighPresIndex; // High Pressure Max Index for Ps (>0.0) + int Num = 0; + + int NumPsPoints = 0; // Number of saturation pressure + Real64 PsLowTempValue = 0.0; // Low Temperature Value for Ps (>0.0) + Real64 PsHighTempValue = 0.0; // High Temperature Value for Ps (max in tables) + int PsLowTempIndex = 0; // Low Temperature Min Index for Ps (>0.0) + int PsHighTempIndex = 0; // High Temperature Max Index for Ps (>0.0) + Real64 PsLowPresValue = 0.0; // Low Pressure Value for Ps (>0.0) + Real64 PsHighPresValue = 0.0; // High Pressure Value for Ps (max in tables) + int PsLowPresIndex = 0; // Low Pressure Min Index for Ps (>0.0) + int PsHighPresIndex = 0; // High Pressure Max Index for Ps (>0.0) Array1D PsTemps; // Temperatures for saturation pressures Array1D PsValues; // Saturation pressures at PsTemps - int NumHPoints; // Number of enthalpy points - Real64 HfLowTempValue; // Low Temperature Value for Hf (>0.0) - Real64 HfHighTempValue; // High Temperature Value for Hf (max in tables) - int HfLowTempIndex; // Low Temperature Min Index for Hf (>0.0) - int HfHighTempIndex; // High Temperature Max Index for Hf (>0.0) - Real64 HfgLowTempValue; // Low Temperature Value for Hfg (>0.0) - Real64 HfgHighTempValue; // High Temperature Value for Hfg (max in tables) - int HfgLowTempIndex; // Low Temperature Min Index for Hfg (>0.0) - int HfgHighTempIndex; // High Temperature Max Index for Hfg (>0.0) + + int NumHPoints = 0; // Number of enthalpy points + Real64 HfLowTempValue = 0.0; // Low Temperature Value for Hf (>0.0) + Real64 HfHighTempValue = 0.0; // High Temperature Value for Hf (max in tables) + int HfLowTempIndex = 0; // Low Temperature Min Index for Hf (>0.0) + int HfHighTempIndex = 0; // High Temperature Max Index for Hf (>0.0) + Real64 HfgLowTempValue = 0.0; // Low Temperature Value for Hfg (>0.0) + Real64 HfgHighTempValue = 0.0; // High Temperature Value for Hfg (max in tables) + int HfgLowTempIndex = 0; // Low Temperature Min Index for Hfg (>0.0) + int HfgHighTempIndex = 0; // High Temperature Max Index for Hfg (>0.0) Array1D HTemps; // Temperatures for enthalpy points Array1D HfValues; // Enthalpy of saturated fluid at HTemps Array1D HfgValues; // Enthalpy of saturated fluid/gas at HTemps - int NumCpPoints; // Number of specific heat of fluid points - Real64 CpfLowTempValue; // Low Temperature Value for Cpf (>0.0) - Real64 CpfHighTempValue; // High Temperature Value for Cpf (max in tables) - int CpfLowTempIndex; // Low Temperature Min Index for Cpf (>0.0) - int CpfHighTempIndex; // High Temperature Max Index for Cpf (>0.0) - Real64 CpfgLowTempValue; // Low Temperature Value for Cpfg (>0.0) - Real64 CpfgHighTempValue; // High Temperature Value for Cpfg (max in tables) - int CpfgLowTempIndex; // Low Temperature Min Index for Cpfg (>0.0) - int CpfgHighTempIndex; // High Temperature Max Index for Cpfg (>0.0) + + int NumCpPoints = 0; // Number of specific heat of fluid points + Real64 CpfLowTempValue = 0.0; // Low Temperature Value for Cpf (>0.0) + Real64 CpfHighTempValue = 0.0; // High Temperature Value for Cpf (max in tables) + int CpfLowTempIndex = 0; // Low Temperature Min Index for Cpf (>0.0) + int CpfHighTempIndex = 0; // High Temperature Max Index for Cpf (>0.0) + Real64 CpfgLowTempValue = 0.0; // Low Temperature Value for Cpfg (>0.0) + Real64 CpfgHighTempValue = 0.0; // High Temperature Value for Cpfg (max in tables) + int CpfgLowTempIndex = 0; // Low Temperature Min Index for Cpfg (>0.0) + int CpfgHighTempIndex = 0; // High Temperature Max Index for Cpfg (>0.0) Array1D CpTemps; // Temperatures for specific heat points Array1D CpfValues; // Specific heat of saturated fluid at CpTemps Array1D CpfgValues; // Specific heat of saturated fluid/gas at CpTemps - int NumRhoPoints; // Number of density of fluid points - Real64 RhofLowTempValue; // Low Temperature Value for Rhof (>0.0) - Real64 RhofHighTempValue; // High Temperature Value for Rhof (max in tables) - int RhofLowTempIndex; // Low Temperature Min Index for Rhof (>0.0) - int RhofHighTempIndex; // High Temperature Max Index for Rhof (>0.0) - Real64 RhofgLowTempValue; // Low Temperature Value for Rhofg (>0.0) - Real64 RhofgHighTempValue; // High Temperature Value for Rhofg (max in tables) - int RhofgLowTempIndex; // Low Temperature Min Index for Rhofg (>0.0) - int RhofgHighTempIndex; // High Temperature Max Index for Rhofg (>0.0) + + int NumRhoPoints = 0; // Number of density of fluid points + Real64 RhofLowTempValue = 0.0; // Low Temperature Value for Rhof (>0.0) + Real64 RhofHighTempValue = 0.0; // High Temperature Value for Rhof (max in tables) + int RhofLowTempIndex = 0; // Low Temperature Min Index for Rhof (>0.0) + int RhofHighTempIndex = 0; // High Temperature Max Index for Rhof (>0.0) + Real64 RhofgLowTempValue = 0.0; // Low Temperature Value for Rhofg (>0.0) + Real64 RhofgHighTempValue = 0.0; // High Temperature Value for Rhofg (max in tables) + int RhofgLowTempIndex = 0; // Low Temperature Min Index for Rhofg (>0.0) + int RhofgHighTempIndex = 0; // High Temperature Max Index for Rhofg (>0.0) Array1D RhoTemps; // Temperatures for density of fluid points Array1D RhofValues; // Density of saturated fluid at RhoTemps Array1D RhofgValues; // Density of saturated fluid/gas at RhoTemps - int NumSuperTempPts; // Number of temperature points for superheated enthalpy - int NumSuperPressPts; // Number of pressure points for superheated enthalpy + + int NumSuperTempPts = 0; // Number of temperature points for superheated enthalpy + int NumSuperPressPts = 0; // Number of pressure points for superheated enthalpy Array1D SHTemps; // Temperatures for superheated gas Array1D SHPress; // Pressures for superheated gas Array2D HshValues; // Enthalpy of superheated gas at HshTemps, HshPress Array2D RhoshValues; // Density of superheated gas at HshTemps, HshPress - // Default Constructor - FluidPropsRefrigerantData() - : NumPsPoints(0), PsLowTempValue(0.0), PsHighTempValue(0.0), PsLowTempIndex(0), PsHighTempIndex(0), PsLowPresValue(0.0), - PsHighPresValue(0.0), PsLowPresIndex(0), PsHighPresIndex(0), NumHPoints(0), HfLowTempValue(0.0), HfHighTempValue(0.0), - HfLowTempIndex(0), HfHighTempIndex(0), HfgLowTempValue(0.0), HfgHighTempValue(0.0), HfgLowTempIndex(0), HfgHighTempIndex(0), - NumCpPoints(0), CpfLowTempValue(0.0), CpfHighTempValue(0.0), CpfLowTempIndex(0), CpfHighTempIndex(0), CpfgLowTempValue(0.0), - CpfgHighTempValue(0.0), CpfgLowTempIndex(0), CpfgHighTempIndex(0), NumRhoPoints(0), RhofLowTempValue(0.0), RhofHighTempValue(0.0), - RhofLowTempIndex(0), RhofHighTempIndex(0), RhofgLowTempValue(0.0), RhofgHighTempValue(0.0), RhofgLowTempIndex(0), RhofgHighTempIndex(0), - NumSuperTempPts(0), NumSuperPressPts(0) - { - } + Real64 getQuality(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Enthalpy, // actual enthalpy given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSatPressure(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSatTemperature(EnergyPlusData &state, + Real64 Pressure, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSatEnthalpy(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Quality, // actual quality given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSatDensity(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Quality, // actual quality given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSatSpecificHeat(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Quality, // actual quality given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSupHeatEnthalpy(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Pressure, // actual pressure given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSupHeatPressure(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Enthalpy, // actual enthalpy given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSupHeatTemp(EnergyPlusData &state, + Real64 Pressure, // actual pressure given as input + Real64 Enthalpy, // actual enthalpy given as input + Real64 TempLow, // lower bound of temperature in the iteration + Real64 TempUp, // upper bound of temperature in the iteration + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getSupHeatDensity(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + Real64 Pressure, // actual pressure given as input + std::string_view CalledFrom); // routine this function was called from (error messages) }; - struct FluidPropsGlycolRawData + struct GlycolRawData { // Members std::string Name; // Name of the glycol - bool CpDataPresent; // Flag set when specific heat data is available - int NumCpTempPts; // Number of temperature points for specific heat - int NumCpConcPts; // Number of concentration points for specific heat + int Num = 0; + + bool CpDataPresent = false; // Flag set when specific heat data is available + int NumCpTempPts = 0; // Number of temperature points for specific heat + int NumCpConcPts = 0; // Number of concentration points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpConcs; // Concentration for specific heat of glycol Array2D CpValues; // Specific heat data values - bool RhoDataPresent; // Flag set when density data is available - int NumRhoTempPts; // Number of temperature points for density - int NumRhoConcPts; // Number of concentration points for density + + bool RhoDataPresent = false; // Flag set when density data is available + int NumRhoTempPts = 0; // Number of temperature points for density + int NumRhoConcPts = 0; // Number of concentration points for density Array1D RhoTemps; // Temperatures for density of glycol Array1D RhoConcs; // Concentration for density of glycol Array2D RhoValues; // Density data values - bool CondDataPresent; // Flag set when conductivity data is available - int NumCondTempPts; // Number of temperature points for conductivity - int NumCondConcPts; // Number of concentration points for conductivity + + bool CondDataPresent = false; // Flag set when conductivity data is available + int NumCondTempPts = 0; // Number of temperature points for conductivity + int NumCondConcPts = 0; // Number of concentration points for conductivity Array1D CondTemps; // Temperatures for conductivity of glycol Array1D CondConcs; // Concentration for conductivity of glycol Array2D CondValues; // conductivity values - bool ViscDataPresent; // Flag set when viscosity data is available - int NumViscTempPts; // Number of temperature points for viscosity - int NumViscConcPts; // Number of concentration points for viscosity + + bool ViscDataPresent = false; // Flag set when viscosity data is available + int NumViscTempPts = 0; // Number of temperature points for viscosity + int NumViscConcPts = 0; // Number of concentration points for viscosity Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscConcs; // Concentration for viscosity of glycol Array2D ViscValues; // viscosity values - - // Default Constructor - FluidPropsGlycolRawData() - : CpDataPresent(false), NumCpTempPts(0), NumCpConcPts(0), RhoDataPresent(false), NumRhoTempPts(0), NumRhoConcPts(0), - CondDataPresent(false), NumCondTempPts(0), NumCondConcPts(0), ViscDataPresent(false), NumViscTempPts(0), NumViscConcPts(0) - { - } }; - struct FluidPropsGlycolData + struct GlycolData { // Members std::string Name; // Name of the glycol mixture (used by other parts of code) + int Num = 0; + std::string GlycolName; // Name of non-water fluid that is part of this mixture // (refers to ethylene glycol, propylene glycol, or user fluid) - int GlycolIndex; // Index in user defined glycol data (>0 = index in raw data, + int BaseGlycolIndex = 0; // Index in user defined glycol data (>0 = index in raw data, // -1=propylene glycol, -2=ethylene glycol) - Real64 Concentration; // Concentration (if applicable) - bool CpDataPresent; // Flag set when specific heat data is available - Real64 CpLowTempValue; // Low Temperature Value for Cp (>0.0) - Real64 CpHighTempValue; // High Temperature Value for Cp (max in tables) - int CpLowTempIndex; // Low Temperature Min Index for Cp (>0.0) - int CpHighTempIndex; // High Temperature Max Index for Cp (>0.0) - int NumCpTempPts; // Number of temperature points for specific heat + Real64 Concentration = 0.0; // Concentration (if applicable) + + bool CpDataPresent = false; // Flag set when specific heat data is available + Real64 CpLowTempValue = 0.0; // Low Temperature Value for Cp (>0.0) + Real64 CpHighTempValue = 0.0; // High Temperature Value for Cp (max in tables) + int CpLowTempIndex = 0; // Low Temperature Min Index for Cp (>0.0) + int CpHighTempIndex = 0; // High Temperature Max Index for Cp (>0.0) + int NumCpTempPts = 0; // Number of temperature points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpValues; // Specific heat data values (J/kg-K) - bool RhoDataPresent; // Flag set when density data is available - int NumRhoTempPts; // Number of temperature points for density - Real64 RhoLowTempValue; // Low Temperature Value for Rho (>0.0) - Real64 RhoHighTempValue; // High Temperature Value for Rho (max in tables) - int RhoLowTempIndex; // Low Temperature Min Index for Rho (>0.0) - int RhoHighTempIndex; // High Temperature Max Index for Rho (>0.0) + + bool RhoDataPresent = false; // Flag set when density data is available + int NumRhoTempPts = 0.0; // Number of temperature points for density + Real64 RhoLowTempValue = 0.0; // Low Temperature Value for Rho (>0.0) + Real64 RhoHighTempValue = 0.0; // High Temperature Value for Rho (max in tables) + int RhoLowTempIndex = 0; // Low Temperature Min Index for Rho (>0.0) + int RhoHighTempIndex = 0; // High Temperature Max Index for Rho (>0.0) Array1D RhoTemps; // Temperatures for density of glycol Array1D RhoValues; // Density data values (kg/m3) - bool CondDataPresent; // Flag set when conductivity data is available - int NumCondTempPts; // Number of temperature points for conductivity - Real64 CondLowTempValue; // Low Temperature Value for Cond (>0.0) - Real64 CondHighTempValue; // High Temperature Value for Cond (max in tables) - int CondLowTempIndex; // Low Temperature Min Index for Cond (>0.0) - int CondHighTempIndex; // High Temperature Max Index for Cond (>0.0) + + bool CondDataPresent = false; // Flag set when conductivity data is available + int NumCondTempPts = 0; // Number of temperature points for conductivity + Real64 CondLowTempValue = 0.0; // Low Temperature Value for Cond (>0.0) + Real64 CondHighTempValue = 0.0; // High Temperature Value for Cond (max in tables) + int CondLowTempIndex = 0; // Low Temperature Min Index for Cond (>0.0) + int CondHighTempIndex = 0; // High Temperature Max Index for Cond (>0.0) Array1D CondTemps; // Temperatures for conductivity of glycol Array1D CondValues; // conductivity values (W/m-K) - bool ViscDataPresent; // Flag set when viscosity data is available - int NumViscTempPts; // Number of temperature points for viscosity - Real64 ViscLowTempValue; // Low Temperature Value for Visc (>0.0) - Real64 ViscHighTempValue; // High Temperature Value for Visc (max in tables) - int ViscLowTempIndex; // Low Temperature Min Index for Visc (>0.0) - int ViscHighTempIndex; // High Temperature Max Index for Visc (>0.0) + + bool ViscDataPresent = false; // Flag set when viscosity data is available + int NumViscTempPts = 0; // Number of temperature points for viscosity + Real64 ViscLowTempValue = 0.0; // Low Temperature Value for Visc (>0.0) + Real64 ViscHighTempValue = 0.0; // High Temperature Value for Visc (max in tables) + int ViscLowTempIndex = 0; // Low Temperature Min Index for Visc (>0.0) + int ViscHighTempIndex = 0; // High Temperature Max Index for Visc (>0.0) Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscValues; // viscosity values (mPa-s) - // Default Constructor - FluidPropsGlycolData() - : GlycolIndex(0), Concentration(1.0), CpDataPresent(false), CpLowTempValue(0.0), CpHighTempValue(0.0), CpLowTempIndex(0), - CpHighTempIndex(0), NumCpTempPts(0), RhoDataPresent(false), NumRhoTempPts(0), RhoLowTempValue(0.0), RhoHighTempValue(0.0), - RhoLowTempIndex(0), RhoHighTempIndex(0), CondDataPresent(false), NumCondTempPts(0), CondLowTempValue(0.0), CondHighTempValue(0.0), - CondLowTempIndex(0), CondHighTempIndex(0), ViscDataPresent(false), NumViscTempPts(0), ViscLowTempValue(0.0), ViscHighTempValue(0.0), - ViscLowTempIndex(0), ViscHighTempIndex(0) - { - } +#ifdef EP_cache_GlycolSpecificHeat + Real64 getSpecificHeat_raw(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom // routine this function was called from (error messages) + ); +#endif + Real64 getSpecificHeat(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getDensity(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getConductivity(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) + + Real64 getViscosity(EnergyPlusData &state, + Real64 Temperature, // actual temperature given as input + std::string_view CalledFrom); // routine this function was called from (error messages) }; - struct FluidPropsRefrigErrors + struct RefrigErrors { // Members std::string Name; - int SatTempErrIndex; // Index for Sat Temperature Error (Recurring errors) - int SatTempErrCount; // Count for Sat Temperature Error (Recurring errors) - int SatPressErrIndex; // Index for Sat Pressure Error (Recurring errors) - int SatPressErrCount; // Count for Sat Pressure Error (Recurring errors) - int SatTempDensityErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatTempDensityErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyTempErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyTempErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyPresErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyPresErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureTempErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureTempErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureEnthErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureEnthErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityTempErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityTempErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityPresErrIndex; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityPresErrCount; // Count for Sat Temperature (Density) Error (Recurring errors) - - // Default Constructor - FluidPropsRefrigErrors() - : SatTempErrIndex(0), SatTempErrCount(0), SatPressErrIndex(0), SatPressErrCount(0), SatTempDensityErrIndex(0), SatTempDensityErrCount(0), - SatSupEnthalpyErrIndex(0), SatSupEnthalpyErrCount(0), SatSupEnthalpyTempErrIndex(0), SatSupEnthalpyTempErrCount(0), - SatSupEnthalpyPresErrIndex(0), SatSupEnthalpyPresErrCount(0), SatSupPressureErrIndex(0), SatSupPressureErrCount(0), - SatSupPressureTempErrIndex(0), SatSupPressureTempErrCount(0), SatSupPressureEnthErrIndex(0), SatSupPressureEnthErrCount(0), - SatSupDensityErrIndex(0), SatSupDensityErrCount(0), SatSupDensityTempErrIndex(0), SatSupDensityTempErrCount(0), - SatSupDensityPresErrIndex(0), SatSupDensityPresErrCount(0) - { - } + int SatTempErrIndex = 0; // Index for Sat Temperature Error (Recurring errors) + int SatTempErrCount = 0; // Count for Sat Temperature Error (Recurring errors) + int SatPressErrIndex = 0; // Index for Sat Pressure Error (Recurring errors) + int SatPressErrCount = 0; // Count for Sat Pressure Error (Recurring errors) + int SatTempDensityErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatTempDensityErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyPresErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupEnthalpyPresErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureEnthErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupPressureEnthErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityPresErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) + int SatSupDensityPresErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) }; - struct FluidPropsGlycolErrors + struct GlycolErrors { // Members std::string Name; // Which glycol this error structure is for - int SpecHeatLowErrIndex; // Index for Specific Heat Low Error (Recurring errors) - int SpecHeatHighErrIndex; // Index for Specific Heat High Error (Recurring errors) - int SpecHeatLowErrCount; // Count for Specific Heat Low Error (Recurring errors) - int SpecHeatHighErrCount; // Count for Specific Heat High Error (Recurring errors) - int DensityHighErrCount; // Index for Density Low Error (Recurring errors) - int DensityLowErrIndex; // Index for Density High Error (Recurring errors) - int DensityHighErrIndex; // Count for Density Low Error (Recurring errors) - int DensityLowErrCount; // Count for Density High Error (Recurring errors) - int ConductivityLowErrIndex; // Index for Conductivity Low Error (Recurring errors) - int ConductivityHighErrIndex; // Index for Conductivity High Error (Recurring errors) - int ConductivityLowErrCount; // Count for Conductivity Low Error (Recurring errors) - int ConductivityHighErrCount; // Count for Conductivity High Error (Recurring errors) - int ViscosityLowErrIndex; // Index for Viscosity Low Error (Recurring errors) - int ViscosityHighErrIndex; // Index for Viscosity High Error (Recurring errors) - int ViscosityLowErrCount; // Count for Viscosity Low Error (Recurring errors) - int ViscosityHighErrCount; // Count for Viscosity High Error (Recurring errors) - - // Default Constructor - FluidPropsGlycolErrors() - : SpecHeatLowErrIndex(0), SpecHeatHighErrIndex(0), SpecHeatLowErrCount(0), SpecHeatHighErrCount(0), DensityHighErrCount(0), - DensityLowErrIndex(0), DensityHighErrIndex(0), DensityLowErrCount(0), ConductivityLowErrIndex(0), ConductivityHighErrIndex(0), - ConductivityLowErrCount(0), ConductivityHighErrCount(0), ViscosityLowErrIndex(0), ViscosityHighErrIndex(0), ViscosityLowErrCount(0), - ViscosityHighErrCount(0) - { - } + int SpecHeatLowErrIndex = 0; // Index for Specific Heat Low Error (Recurring errors) + int SpecHeatHighErrIndex = 0; // Index for Specific Heat High Error (Recurring errors) + int SpecHeatLowErrCount = 0; // Count for Specific Heat Low Error (Recurring errors) + int SpecHeatHighErrCount = 0; // Count for Specific Heat High Error (Recurring errors) + int DensityHighErrCount = 0; // Index for Density Low Error (Recurring errors) + int DensityLowErrIndex = 0; // Index for Density High Error (Recurring errors) + int DensityHighErrIndex = 0; // Count for Density Low Error (Recurring errors) + int DensityLowErrCount = 0; // Count for Density High Error (Recurring errors) + int ConductivityLowErrIndex = 0; // Index for Conductivity Low Error (Recurring errors) + int ConductivityHighErrIndex = 0; // Index for Conductivity High Error (Recurring errors) + int ConductivityLowErrCount = 0; // Count for Conductivity Low Error (Recurring errors) + int ConductivityHighErrCount = 0; // Count for Conductivity High Error (Recurring errors) + int ViscosityLowErrIndex = 0; // Index for Viscosity Low Error (Recurring errors) + int ViscosityHighErrIndex = 0; // Index for Viscosity High Error (Recurring errors) + int ViscosityLowErrCount = 0; // Count for Viscosity Low Error (Recurring errors) + int ViscosityHighErrCount = 0; // Count for Viscosity High Error (Recurring errors) }; struct cached_tsh @@ -374,6 +414,14 @@ namespace Fluid { void ReportAndTestRefrigerants(EnergyPlusData &state); + Real64 GetQualityRefrig(EnergyPlusData &state, + std::string const &Refrigerant, // carries in substance name + Real64 Temperature, // actual temperature given as input + Real64 Enthalpy, // actual enthalpy given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view CalledFrom // routine this function was called from (error messages) + ); + Real64 GetSatPressureRefrig(EnergyPlusData &state, std::string_view Refrigerant, // carries in substance name Real64 Temperature, // actual temperature given as input @@ -446,14 +494,6 @@ namespace Fluid { std::string_view CalledFrom // routine this function was called from (error messages) ); -#ifdef EP_cache_GlycolSpecificHeat - Real64 GetSpecificHeatGlycol_raw(EnergyPlusData &state, - std::string_view Glycol, // carries in substance name - Real64 Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view CalledFrom // routine this function was called from (error messages) - ); -#endif Real64 GetSpecificHeatGlycol(EnergyPlusData &state, std::string_view Glycol, // carries in substance name Real64 Temperature, // actual temperature given as input @@ -528,17 +568,11 @@ namespace Fluid { return Xhi - (((Thi - Tact) / (Thi - Tlo)) * (Xhi - Xlo)); } - Real64 GetQualityRefrig(EnergyPlusData &state, - std::string const &Refrigerant, // carries in substance name - Real64 Temperature, // actual temperature given as input - Real64 Enthalpy, // actual enthalpy given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view CalledFrom // routine this function was called from (error messages) - ); - - int FindRefrigerant(EnergyPlusData &state, std::string_view Rrefrigerant); // carries in substance name - - int FindGlycol(EnergyPlusData &state, std::string_view Glycol); // carries in substance name + int GetRefrigNum(EnergyPlusData &state, std::string_view name); + RefrigerantData *GetRefrig(EnergyPlusData &state, std::string_view name); + + int GetGlycolNum(EnergyPlusData &state, std::string_view name); + GlycolData *GetGlycol(EnergyPlusData &state, std::string_view name); std::string GetGlycolNameByIndex(EnergyPlusData &state, int Idx); // carries in substance index @@ -637,11 +671,11 @@ struct FluidData : BaseGlobalStruct Array1D_bool RefrigUsed; Array1D_bool GlycolUsed; - Array1D RefrigData; - Array1D RefrigErrorTracking; - Array1D GlyRawData; - Array1D GlycolData; - Array1D GlycolErrorTracking; + Array1D RefrigData; + Array1D RefrigErrorTracking; + Array1D GlyRawData; + Array1D GlycolData; + Array1D GlycolErrorTracking; int SatErrCountGetSupHeatEnthalpyRefrig = 0; int SatErrCountGetSupHeatDensityRefrig = 0; @@ -659,12 +693,12 @@ struct FluidData : BaseGlobalStruct int TempRangeErrIndexGetInterpolatedSatProp = 0; #ifdef EP_cache_GlycolSpecificHeat - std::array cached_t_sh; + std::array cached_t_sh; #endif void init_state(EnergyPlusData &state) override { - Fluid::GetFluidPropertiesData(state); + FluidProperties::GetFluidPropertiesData(state); this->GetInput = false; } diff --git a/src/EnergyPlus/FuelCellElectricGenerator.cc b/src/EnergyPlus/FuelCellElectricGenerator.cc index 6a9a94be210..47a55dcc2b1 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.cc +++ b/src/EnergyPlus/FuelCellElectricGenerator.cc @@ -3032,7 +3032,7 @@ namespace FuelCellElectricGenerator { this->ExhaustHX.THXexh = TprodGasIn - this->ExhaustHX.qHX / (NdotGas * CpProdGasMol * 1000.0); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, TwaterIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3368,7 +3368,7 @@ namespace FuelCellElectricGenerator { this->Inverter.PCUlosses = 0.0; this->Inverter.QairIntake = 0.0; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, DataGenerators::InitHRTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index 86bc6ce5de9..941c5288275 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -1130,7 +1130,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getUnitaryHeatOnly); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -1672,7 +1672,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -2129,7 +2129,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -3138,7 +3138,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -3953,7 +3953,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, getAirLoopHVACHeatCoolInput); thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity; @@ -4786,7 +4786,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidIndex, @@ -4812,7 +4812,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity; } @@ -4849,7 +4849,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidIndex, @@ -4874,7 +4874,7 @@ namespace Furnaces { thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound); if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxSuppCoilFluidFlow *= SteamDensity; } @@ -4917,7 +4917,7 @@ namespace Furnaces { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).FluidIndex, @@ -4936,7 +4936,7 @@ namespace Furnaces { CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -4955,7 +4955,7 @@ namespace Furnaces { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum).FluidIndex, @@ -4973,7 +4973,7 @@ namespace Furnaces { CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataFurnaces->TempSteamIn, 1.0, SteamIndex, RoutineName); thisFurnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } diff --git a/src/EnergyPlus/GroundHeatExchangers.cc b/src/EnergyPlus/GroundHeatExchangers.cc index f9d102c5e20..7c86b973419 100644 --- a/src/EnergyPlus/GroundHeatExchangers.cc +++ b/src/EnergyPlus/GroundHeatExchangers.cc @@ -1137,12 +1137,12 @@ void GLHEVert::calcShortTimestepGFunctions(EnergyPlusData &state) Real64 bh_equivalent_resistance_convection = bhResistance - bh_equivalent_resistance_tube_grout; Real64 initial_temperature = this->inletTemp; - Real64 cpFluid_init = Fluid::GetSpecificHeatGlycol(state, + Real64 cpFluid_init = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, initial_temperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidDensity_init = Fluid::GetDensityGlycol(state, + Real64 fluidDensity_init = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, initial_temperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2004,7 +2004,7 @@ void GLHEBase::calcGroundHeatExchanger(EnergyPlusData &state) this->inletTemp = state.dataLoopNodes->Node(this->inletNodeNum).Temp; - Real64 cpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2275,7 +2275,7 @@ void GLHEBase::updateGHX(EnergyPlusData &state) state.dataLoopNodes->Node(this->outletNodeNum).Temp = this->outletTemp; state.dataLoopNodes->Node(this->outletNodeNum).Enthalpy = - this->outletTemp * Fluid::GetSpecificHeatGlycol(state, + this->outletTemp * FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->outletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2284,7 +2284,7 @@ void GLHEBase::updateGHX(EnergyPlusData &state) Real64 GLHEdeltaTemp = std::abs(this->outletTemp - this->inletTemp); if (GLHEdeltaTemp > deltaTempLimit && this->numErrorCalls < state.dataGroundHeatExchanger->numVerticalGLHEs && !state.dataGlobal->WarmupFlag) { - Real64 fluidDensity = Fluid::GetDensityGlycol(state, + Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2636,7 +2636,7 @@ Real64 GLHEVert::calcHXResistance(EnergyPlusData &state) } else { std::string_view const RoutineName = "calcBHResistance"; - Real64 const cpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 const cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2671,17 +2671,17 @@ Real64 GLHEVert::calcPipeConvectionResistance(EnergyPlusData &state) // Get fluid props this->inletTemp = state.dataLoopNodes->Node(this->inletNodeNum).Temp; - Real64 const cpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 const cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const kFluid = Fluid::GetConductivityGlycol(state, + Real64 const kFluid = FluidProperties::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 const fluidViscosity = Fluid::GetViscosityGlycol(state, + Real64 const fluidViscosity = FluidProperties::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2775,22 +2775,22 @@ Real64 GLHESlinky::calcHXResistance(EnergyPlusData &state) constexpr Real64 B = 350; constexpr Real64 laminarNusseltNo = 4.364; - Real64 cpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 kFluid = Fluid::GetConductivityGlycol(state, + Real64 kFluid = FluidProperties::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidDensity = Fluid::GetDensityGlycol(state, + Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 fluidViscosity = Fluid::GetViscosityGlycol(state, + Real64 fluidViscosity = FluidProperties::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2951,7 +2951,7 @@ void GLHEVert::initEnvironment(EnergyPlusData &state, [[maybe_unused]] Real64 co std::string_view const RoutineName = "initEnvironment"; this->myEnvrnFlag = false; - Real64 fluidDensity = Fluid::GetDensityGlycol(state, + Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -3026,7 +3026,7 @@ void GLHESlinky::initEnvironment(EnergyPlusData &state, Real64 const CurTime) std::string_view const RoutineName = "initEnvironment"; this->myEnvrnFlag = false; - Real64 fluidDensity = Fluid::GetDensityGlycol(state, + Real64 fluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HVACControllers.cc b/src/EnergyPlus/HVACControllers.cc index 635bb5e5f83..a0a1ba563e2 100644 --- a/src/EnergyPlus/HVACControllers.cc +++ b/src/EnergyPlus/HVACControllers.cc @@ -1021,7 +1021,7 @@ void InitController(EnergyPlusData &state, int const ControlNum, bool &IsConverg // Do the Begin Environment initializations if (state.dataGlobal->BeginEnvrnFlag && MyEnvrnFlag(ControlNum)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisController.ActuatedNodePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(thisController.ActuatedNodePlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HVACCooledBeam.cc b/src/EnergyPlus/HVACCooledBeam.cc index 14f38030df9..635b0f71340 100644 --- a/src/EnergyPlus/HVACCooledBeam.cc +++ b/src/EnergyPlus/HVACCooledBeam.cc @@ -508,7 +508,7 @@ namespace HVACCooledBeam { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -647,8 +647,8 @@ namespace HVACCooledBeam { // Using/Aliasing using namespace DataSizing; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::MyPlantSizingIndex; using PlantUtilities::RegisterPlantCompDesignFlow; @@ -1021,8 +1021,8 @@ namespace HVACCooledBeam { // na // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // Locals diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index b6d8b3ba734..47961c0e382 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -734,8 +734,8 @@ namespace FourPipeBeam { // Using using namespace DataSizing; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::MyPlantSizingIndex; using PlantUtilities::RegisterPlantCompDesignFlow; using Psychrometrics::PsyCpAirFnW; @@ -871,7 +871,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -884,7 +884,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -951,7 +951,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -964,7 +964,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -1034,7 +1034,7 @@ namespace FourPipeBeam { } if (this->beamCoolingPresent) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).FluidIndex, @@ -1044,7 +1044,7 @@ namespace FourPipeBeam { PlantUtilities::InitComponentNodes(state, 0.0, this->mDotDesignCW, this->cWInNodeNum, this->cWOutNodeNum); } if (this->beamHeatingPresent) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).FluidIndex, @@ -1244,8 +1244,8 @@ namespace FourPipeBeam { { // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // Locals diff --git a/src/EnergyPlus/HVACInterfaceManager.cc b/src/EnergyPlus/HVACInterfaceManager.cc index 54a1e257a13..d292194eacc 100644 --- a/src/EnergyPlus/HVACInterfaceManager.cc +++ b/src/EnergyPlus/HVACInterfaceManager.cc @@ -506,7 +506,7 @@ void UpdatePlantLoopInterface(EnergyPlusData &state, Real64 OldTankOutletTemp = state.dataLoopNodes->Node(OtherLoopSideInletNode).Temp; // calculate the specific heat - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, OldTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // update the enthalpy @@ -660,7 +660,7 @@ void UpdateHalfLoopInletTemp(EnergyPlusData &state, int const LoopNum, const Dat Real64 LastTankOutletTemp = state.dataPlnt->PlantLoop(LoopNum).LoopSide(TankOutletLoopSide).LastTempInterfaceTankOutlet; // calculate the specific heat for the capacitance calculation - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LastTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // set the fraction of loop mass assigned to each half loop outlet capacitance ('tank') calculation @@ -791,7 +791,7 @@ void UpdateCommonPipe(EnergyPlusData &state, Real64 LastTankOutletTemp = state.dataPlnt->PlantLoop(LoopNum).LoopSide(TankOutletLoopSide).LastTempInterfaceTankOutlet; // calculate the specific heat for the capacitance calculation - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LastTankOutletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); // set the fraction of loop mass assigned to each half loop outlet capacitance ('tank') calculation diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index b203328f07f..3f243b24ac4 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -904,7 +904,7 @@ namespace HVACMultiSpeedHeatPump { thisMSHP.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.HeatCoilNum, errFlag); if (thisMSHP.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, routineName); thisMSHP.MaxCoilFluidFlow *= SteamDensity; } @@ -1176,7 +1176,7 @@ namespace HVACMultiSpeedHeatPump { thisMSHP.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.SuppHeatCoilNum, errFlag); if (thisMSHP.MaxSuppCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, routineName); thisMSHP.MaxSuppCoilFluidFlow *= SteamDensity; } @@ -1841,7 +1841,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidIndex, @@ -1874,7 +1874,7 @@ namespace HVACMultiSpeedHeatPump { if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed // TODO: Why do you want to re-look this up? - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow *= SteamDensity; } @@ -1903,7 +1903,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidIndex, @@ -1936,7 +1936,7 @@ namespace HVACMultiSpeedHeatPump { SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow *= SteamDensity; } @@ -2058,7 +2058,7 @@ namespace HVACMultiSpeedHeatPump { if ((MSHeatPump(MSHeatPumpNum).HeatRecActive) && (!MSHeatPump(MSHeatPumpNum).MyPlantScantFlag)) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidIndex, @@ -2081,7 +2081,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum).FluidIndex, @@ -2106,7 +2106,7 @@ namespace HVACMultiSpeedHeatPump { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -2127,7 +2127,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -2153,7 +2153,7 @@ namespace HVACMultiSpeedHeatPump { if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, SteamIndex, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } @@ -3945,7 +3945,7 @@ namespace HVACMultiSpeedHeatPump { if (HeatRecMassFlowRate > 0.0) { // Heat reclaim water inlet specific heat [J/kg-K] - Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol( + Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum).FluidName, HeatRecInletTemp, diff --git a/src/EnergyPlus/HVACSingleDuctInduc.cc b/src/EnergyPlus/HVACSingleDuctInduc.cc index d5171cd2d17..a7fd16f81b8 100644 --- a/src/EnergyPlus/HVACSingleDuctInduc.cc +++ b/src/EnergyPlus/HVACSingleDuctInduc.cc @@ -620,7 +620,7 @@ namespace HVACSingleDuctInduc { int HotConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode; if (HotConNode > 0 && !state.dataHVACSingleDuctInduc->MyPlantScanFlag(IUNum)) { - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -641,7 +641,7 @@ namespace HVACSingleDuctInduc { int ColdConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode; if (ColdConNode > 0) { - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, @@ -850,14 +850,14 @@ namespace HVACSingleDuctInduc { state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU); } state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesHeatingLoad = DesCoilLoad; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -985,14 +985,14 @@ namespace HVACSingleDuctInduc { state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneSizThermSetPtHi); } state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesCoolingLoad = DesCoilLoad; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum).FluidName, 5.0, diff --git a/src/EnergyPlus/HVACSizingSimulationManager.cc b/src/EnergyPlus/HVACSizingSimulationManager.cc index 5eb14ef0172..9dd268ccea2 100644 --- a/src/EnergyPlus/HVACSizingSimulationManager.cc +++ b/src/EnergyPlus/HVACSizingSimulationManager.cc @@ -97,12 +97,12 @@ void HVACSizingSimulationManager::CreateNewCoincidentPlantAnalysisObject(EnergyP for (int i = 1; i <= state.dataPlnt->TotNumLoops; ++i) { if (PlantLoopName == state.dataPlnt->PlantLoop(i).Name) { // found it - density = Fluid::GetDensityGlycol(state, + density = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(i).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(i).FluidIndex, "createNewCoincidentPlantAnalysisObject"); - cp = Fluid::GetSpecificHeatGlycol(state, + cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(i).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(i).FluidIndex, diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.cc b/src/EnergyPlus/HVACUnitaryBypassVAV.cc index f1ae2872352..b12b3213faf 100644 --- a/src/EnergyPlus/HVACUnitaryBypassVAV.cc +++ b/src/EnergyPlus/HVACUnitaryBypassVAV.cc @@ -901,7 +901,7 @@ namespace HVACUnitaryBypassVAV { thisCBVAV.CoilControlNode = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).SteamInletNodeNum; thisCBVAV.MaxHeatCoilFluidFlow = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).MaxSteamVolFlowRate; int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 SteamDensity = Fluid::GetSatDensityRefrig( + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, getUnitaryHeatCoolVAVChangeoverBypass); if (thisCBVAV.MaxHeatCoilFluidFlow > 0.0) { thisCBVAV.MaxHeatCoilFluidFlow = thisCBVAV.MaxHeatCoilFluidFlow * SteamDensity; @@ -1382,7 +1382,7 @@ namespace HVACUnitaryBypassVAV { cBVAV.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound); if (cBVAV.MaxHeatCoilFluidFlow > 0.0) { - Real64 FluidDensity = Fluid::GetDensityGlycol(state, + Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidIndex, @@ -1405,7 +1405,7 @@ namespace HVACUnitaryBypassVAV { if (cBVAV.MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = Fluid::GetSatDensityRefrig( + Real64 FluidDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, RoutineName); cBVAV.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cBVAV.HeatCoilIndex, ErrorsFound) * FluidDensity; } @@ -1480,7 +1480,7 @@ namespace HVACUnitaryBypassVAV { ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name)); } if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 FluidDensity = Fluid::GetDensityGlycol(state, + Real64 FluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).FluidIndex, @@ -1502,7 +1502,7 @@ namespace HVACUnitaryBypassVAV { } if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed - Real64 FluidDensity = Fluid::GetSatDensityRefrig( + Real64 FluidDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, SteamIndex, RoutineName); cBVAV.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index 155b4cd2731..50b61cac8c2 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -358,7 +358,6 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond) // If terminal units require more capacity than can be delivered by condenser, a limit is set. using Curve::CurveValue; - using Fluid::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; using Psychrometrics::RhoH2O; @@ -1268,7 +1267,7 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond) // VRF( VRFCond ).CondenserInletTemp = state.dataLoopNodes->Node(VRF(VRFCond).CondenserNodeNum).Temp; vrf.WaterCondenserMassFlow = state.dataLoopNodes->Node(vrf.CondenserNodeNum).MassFlowRate; - CpCond = GetSpecificHeatGlycol(state, + CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidName, vrf.CondenserInletTemp, state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidIndex, @@ -2453,6 +2452,9 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); + + ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; + GlobalNames::VerifyUniqueInterObjectName( state, state.dataHVACVarRefFlow->VrfUniqueNames, cAlphaArgs(1), cCurrentModuleObject, cAlphaFieldNames(1), ErrorsFound); @@ -2483,13 +2485,13 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) } // Refrigerant type - thisVrfFluidCtrl.RefrigerantName = cAlphaArgs(4); - if (Util::FindItemInList(thisVrfFluidCtrl.RefrigerantName, state.dataFluid->RefrigData, state.dataFluid->NumOfRefrigerants) == 0) { - ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrl.Name); - ShowContinueError(state, "Illegal " + cAlphaFieldNames(4) + " = " + cAlphaArgs(4)); + thisVrfFluidCtrl.refrigName = cAlphaArgs(4); + thisVrfFluidCtrl.refrig = FluidProperties::GetRefrig(state, thisVrfFluidCtrl.refrigName); + if (thisVrfFluidCtrl.refrig == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(4), cAlphaArgs(4)); ErrorsFound = true; } - + thisVrfFluidCtrl.RatedEvapCapacity = rNumericArgs(1); thisVrfFluidCtrl.RatedCompPowerPerCapcity = rNumericArgs(2); thisVrfFluidCtrl.RatedCompPower = thisVrfFluidCtrl.RatedCompPowerPerCapcity * thisVrfFluidCtrl.RatedEvapCapacity; @@ -2844,6 +2846,9 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); + + ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; + GlobalNames::VerifyUniqueInterObjectName( state, state.dataHVACVarRefFlow->VrfUniqueNames, cAlphaArgs(1), cCurrentModuleObject, cAlphaFieldNames(1), ErrorsFound); @@ -2878,11 +2883,9 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) } // Refrigerant type - thisVrfFluidCtrlHR.RefrigerantName = cAlphaArgs(4); - if (Util::FindItemInList(thisVrfFluidCtrlHR.RefrigerantName, state.dataFluid->RefrigData, state.dataFluid->NumOfRefrigerants) == - 0) { - ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfFluidCtrlHR.Name); - ShowContinueError(state, "Illegal " + cAlphaFieldNames(4) + " = " + cAlphaArgs(4)); + thisVrfFluidCtrlHR.refrigName = cAlphaArgs(4); + if ((thisVrfFluidCtrlHR.refrig = FluidProperties::GetRefrig(state, thisVrfFluidCtrlHR.refrigName)) == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(4), cAlphaArgs(4)); ErrorsFound = true; } @@ -4292,7 +4295,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) if (thisVrfTU.SuppHeatCoilFluidMaxFlow > 0.0) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); thisVrfTU.SuppHeatCoilFluidMaxFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisVrfTU.SuppHeatCoilIndex, errFlag) * SteamDensity; } @@ -5519,7 +5522,6 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool using DataSizing::AutoSize; using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using ScheduleManager::GetCurrentScheduleValue; @@ -5654,7 +5656,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound); if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) { - rho = GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidIndex, @@ -5689,7 +5691,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow * SteamDensity; } @@ -6266,7 +6268,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state.dataHVACVarRefFlow->MyEnvrnFlag(VRFTUNum) = false; if (state.dataHVACVarRefFlow->VRF(VRFCond).CondenserType == DataHeatBalance::RefrigCondenserType::Water) { - rho = GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, @@ -6297,7 +6299,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -6321,7 +6323,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool if (CoilMaxVolFlowRate != DataSizing::AutoSize) { int SteamIndex = 0; // fluid type index of 0 is passed if steam Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -8907,13 +8909,13 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) if (this->WaterCondVolFlowRate == DataSizing::AutoSize) { if (this->SourcePlantLoc.loopNum > 0) PltSizCondNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (PltSizCondNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -8929,7 +8931,7 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) this->WaterCondVolFlowRate); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -11023,14 +11025,6 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // A new physics based VRF model applicable for Fluid Temperature Control. using Curve::CurveValue; - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSpecificHeatGlycol; - using Fluid::GetSupHeatDensityRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; using PlantUtilities::SetComponentFlowRate; @@ -11095,7 +11089,6 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) int Counter; // index for iterations [-] int NumIteHIUIn; // index for HIU calculation iterations [-] int NumOfCompSpdInput; // Number of compressor speed input by the user [-] - int RefrigerantIndex; // Index of the refrigerant [-] Real64 CompSpdActual; // Actual compressor running speed [rps] Real64 C_cap_operation; // Compressor capacity modification algorithm_modified Cap [-] Real64 CompEvaporatingCAPSpdMin; // evaporating capacity at the lowest compressor speed [W] @@ -11192,7 +11185,6 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) NumTUInCoolingMode = 0; NumTUInHeatingMode = 0; Tolerance = 0.05; - RefrigerantIndex = -1; Counter = 1; NumIteHIUIn = 1; this->ElecCoolingPower = 0.0; @@ -11212,13 +11204,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // Refrigerant data RefMinTe = -15; RefMaxPc = 4000000.0; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefMinPe = GetSatPressureRefrig(state, this->RefrigerantName, RefMinTe, RefrigerantIndex, RoutineName); - RefMinPe = GetSatPressureRefrig(state, this->RefrigerantName, RefMinTe, RefrigerantIndex, RoutineName); - RefTLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowTempValue; // High Temperature Value for Ps (max in tables) - RefTHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) + RefMinPe = this->refrig->getSatPressure(state, RefMinTe, RoutineName); + RefTLow = this->refrig->PsLowTempValue; // High Temperature Value for Ps (max in tables) + RefTHigh = this->refrig->PsHighTempValue; // High Temperature Value for Ps (max in tables) + RefPLow = this->refrig->PsLowPresValue; // Low Pressure Value for Ps (>0.0) + RefPHigh = this->refrig->PsHighPresValue; // High Pressure Value for Ps (max in tables) // sum loads on TU coils for (NumTU = 1; NumTU <= NumTUInList; ++NumTU) { @@ -11320,7 +11310,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Q_c_TU_PL = TU_CoolingLoad; // Evaporator (IU side) operational parameters - Pevap = GetSatPressureRefrig(state, this->RefrigerantName, this->IUEvaporatingTemp, RefrigerantIndex, RoutineName); + Pevap = this->refrig->getSatPressure(state, this->IUEvaporatingTemp, RoutineName); Psuction = Pevap; Tsuction = this->IUEvaporatingTemp; // GetSatTemperatureRefrig(state, this->RefrigerantName, max( min( Psuction, RefPHigh ), RefPLow ), // RefrigerantIndex, RoutineName ); @@ -11330,13 +11320,13 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // Condenser (OU side) operation ranges CapMaxPc = min(Psuction + this->CompMaxDeltaP, RefMaxPc); - CapMaxTc = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMaxPc, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + CapMaxTc = this->refrig->getSatTemperature(state, max(min(CapMaxPc, RefPHigh), RefPLow), RoutineName); CapMinTc = OutdoorDryBulb + this->SC; - CapMinPc = GetSatPressureRefrig(state, this->RefrigerantName, CapMinTc, RefrigerantIndex, RoutineName); + CapMinPc = this->refrig->getSatPressure(state, CapMinTc, RoutineName); // Evaporator (IU side) operation ranges CapMinPe = max(CapMinPc - this->CompMaxDeltaP, RefMinPe); - CapMinTe = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMinPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + CapMinTe = this->refrig->getSatTemperature(state, max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); // Evaporative capacity ranges CompEvaporatingCAPSpdMin = this->CoffEvapCap * this->RatedEvapCapacity * CurveValue(state, this->OUCoolingCAPFT(1), CapMinTc, CapMinTe); @@ -11347,12 +11337,9 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) this->RatedCompPower * CurveValue(state, this->OUCoolingPWRFT(NumOfCompSpdInput), this->CondensingTemp, this->IUEvaporatingTemp); // Initialization for h_IU_evap_in iterations (Label12) - h_IU_evap_in_low = - GetSatEnthalpyRefrig(state, this->RefrigerantName, OutdoorDryBulb - this->SC, 0.0, RefrigerantIndex, RoutineName); // Tc = Tamb - h_IU_evap_in_up = - GetSatEnthalpyRefrig(state, this->RefrigerantName, CapMaxTc - this->SC, 0.0, RefrigerantIndex, RoutineName); // Tc = CapMaxTc - h_IU_evap_in = - GetSatEnthalpyRefrig(state, this->RefrigerantName, OutdoorDryBulb + 10 - this->SC, 0.0, RefrigerantIndex, RoutineName); // Tc = Tamb+10 + h_IU_evap_in_low = this->refrig->getSatEnthalpy(state, OutdoorDryBulb - this->SC, 0.0, RoutineName); // Tc = Tamb + h_IU_evap_in_up = this->refrig->getSatEnthalpy(state, CapMaxTc - this->SC, 0.0, RoutineName); // Tc = CapMaxTc + h_IU_evap_in = this->refrig->getSatEnthalpy(state, OutdoorDryBulb + 10 - this->SC, 0.0, RoutineName); // Tc = Tamb+10 NumIteHIUIn = 1; Label12:; @@ -11369,13 +11356,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Q_c_TU_PL = CompEvaporatingCAPSpdMax; TU_CoolingLoad = CompEvaporatingCAPSpdMax; this->TUCoolingLoad = TU_CoolingLoad; - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_IU_evap_out = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, - max(RefTSat, this->IUEvaporatingTemp + 3), - max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, - RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); @@ -11386,14 +11368,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex; - RefTSat = - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_IU_evap_out_i = - GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out_i = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); if (h_IU_evap_out_i > h_IU_evap_in) { @@ -11411,13 +11389,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_evap_out = h_IU_evap_out / m_ref_IU_evap; SH_IU_merged = SH_IU_merged / m_ref_IU_evap; } else { - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_IU_evap_out = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, - max(RefTSat, this->IUEvaporatingTemp + 3), - max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, - RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, + max(RefTSat, this->IUEvaporatingTemp + 3), + max(min(Pevap, RefPHigh), RefPLow), + RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); } @@ -11426,18 +11402,15 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // *Calculate piping loss this->VRFOU_PipeLossC( state, m_ref_IU_evap, max(min(Pevap, RefPHigh), RefPLow), h_IU_evap_out, SH_IU_merged, OutdoorDryBulb, Pipe_Q_c, Pipe_DeltP_c, h_comp_in); - Tsuction = - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap - Pipe_DeltP_c, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Tsuction = this->refrig->getSatTemperature(state, max(min(Pevap - Pipe_DeltP_c, RefPHigh), RefPLow), RoutineName); Psuction = Pevap - Pipe_DeltP_c; // This Psuction is used for rps > min; will be updated for rps = min // Perform iteration to calculate T_comp_in - T_comp_in = GetSupHeatTempRefrig(state, - this->RefrigerantName, + T_comp_in = this->refrig->getSupHeatTemp(state, max(min(Pevap - Pipe_DeltP_c, RefPHigh), RefPLow), h_comp_in, Tsuction + 3, Tsuction + 30, - RefrigerantIndex, RoutineName); SH_Comp = T_comp_in - Tsuction; // This is used for rps > min; will be updated for rps = min @@ -11501,7 +11474,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) } // Update h_IU_evap_in in iterations Label12 - h_IU_evap_in_new = GetSatEnthalpyRefrig(state, this->RefrigerantName, this->CondensingTemp - this->SC, 0.0, RefrigerantIndex, RoutineName); + h_IU_evap_in_new = this->refrig->getSatEnthalpy(state, this->CondensingTemp - this->SC, 0.0, RoutineName); if ((std::abs(h_IU_evap_in - h_IU_evap_in_new) > Tolerance * h_IU_evap_in) && (h_IU_evap_in < h_IU_evap_in_up) && (h_IU_evap_in > h_IU_evap_in_low)) { h_IU_evap_in = h_IU_evap_in_new; @@ -11561,12 +11534,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) this->RatedCompPower * CurveValue(state, this->OUCoolingPWRFT(NumOfCompSpdInput), this->IUCondensingTemp, CapMaxTe); // Initialization of h_comp_out iterations (Label23) - Pcond = GetSatPressureRefrig(state, this->RefrigerantName, 40.0, RefrigerantIndex, RoutineName); - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, Pcond, RefrigerantIndex, RoutineName); - h_IU_cond_in_up = GetSupHeatEnthalpyRefrig( - state, this->RefrigerantName, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond, RefrigerantIndex, RoutineName); - h_IU_cond_in_low = - GetSatEnthalpyRefrig(state, this->RefrigerantName, this->IUCondensingTemp, 1.0, RefrigerantIndex, RoutineName); // Quality=1 + Pcond = this->refrig->getSatPressure(state, 40.0, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, Pcond, RoutineName); + h_IU_cond_in_up = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond, RoutineName); + h_IU_cond_in_low = this->refrig->getSatEnthalpy(state, this->IUCondensingTemp, 1.0, RoutineName); // Quality=1 h_IU_cond_in = h_IU_cond_in_low; Label23:; @@ -11578,12 +11549,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (Q_h_TU_PL > CompEvaporatingCAPSpdMax + CompEvaporatingPWRSpdMax) { // Required load is beyond the max system capacity - h_IU_cond_out = GetSatEnthalpyRefrig( + h_IU_cond_out = this->refrig->getSatEnthalpy( state, - this->RefrigerantName, - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) - 5.0, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, 0.0, - RefrigerantIndex, RoutineName); // Quality=0 h_IU_cond_out_ave = h_IU_cond_out; SC_IU_merged = 5; @@ -11594,13 +11563,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) { TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex; - h_IU_cond_out_i = GetSatEnthalpyRefrig( + h_IU_cond_out_i = this->refrig->getSatEnthalpy( state, - this->RefrigerantName, - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) - + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, 0.0, - RefrigerantIndex, RoutineName); // Quality=0 m_ref_IU_cond_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) <= 0.0) @@ -11615,12 +11582,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_cond_out_ave = h_IU_cond_out_ave / m_ref_IU_cond; // h_merge SC_IU_merged = SC_IU_merged / m_ref_IU_cond; } else { - h_IU_cond_out_ave = GetSatEnthalpyRefrig( + h_IU_cond_out_ave = this->refrig->getSatEnthalpy( state, - this->RefrigerantName, - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) - 5.0, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, 0.0, - RefrigerantIndex, RoutineName); // Quality=0 SC_IU_merged = 5; m_ref_IU_cond = TU_HeatingLoad / (h_IU_cond_in - h_IU_cond_out_ave); @@ -11632,11 +11597,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) state, m_ref_IU_cond, max(min(Pcond, RefPHigh), RefPLow), h_IU_cond_in, OutdoorDryBulb, Pipe_Q_h, Pipe_DeltP_h, h_comp_out); Pdischarge = max(Pcond + Pipe_DeltP_h, Pcond); // affected by piping loss - Tdischarge = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pdischarge, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Tdischarge = this->refrig->getSatTemperature(state, max(min(Pdischarge, RefPHigh), RefPLow), RoutineName); // Evaporative capacity ranges_Min CapMinPe = min(Pdischarge - this->CompMaxDeltaP, RefMinPe); - CapMinTe = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMinPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + CapMinTe = this->refrig->getSatTemperature(state, max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); CompEvaporatingCAPSpdMin = this->CoffEvapCap * this->RatedEvapCapacity * CurveValue(state, this->OUCoolingCAPFT(1), Tdischarge, CapMinTe); CompEvaporatingPWRSpdMin = this->RatedCompPower * CurveValue(state, this->OUCoolingPWRFT(1), Tdischarge, CapMinTe); @@ -11644,9 +11609,9 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Q_c_OU = max(0.0, Q_h_TU_PL - CompEvaporatingPWRSpdMin); // *Calculate capacity modification factor - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMinPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_comp_in = GetSupHeatEnthalpyRefrig( - state, this->RefrigerantName, max(RefTSat, CapMinTe + this->SH), max(min(CapMinPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); + h_comp_in = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, CapMinTe + this->SH), max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); C_cap_operation = this->VRFOU_CapModFactor(state, h_comp_in, h_IU_cond_out_ave, @@ -11740,13 +11705,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) } // Update h_comp_out in iteration Label23 - P_comp_in = GetSatPressureRefrig(state, this->RefrigerantName, this->EvaporatingTemp, RefrigerantIndex, RoutineName); - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(P_comp_in, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_comp_in_new = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + P_comp_in = this->refrig->getSatPressure(state, this->EvaporatingTemp, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(P_comp_in, RefPHigh), RefPLow), RoutineName); + h_comp_in_new = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->SH + this->EvaporatingTemp), max(min(P_comp_in, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); h_comp_out_new = Ncomp_new / m_ref_IU_cond + h_comp_in_new; @@ -11796,32 +11759,31 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Q_h_TU_PL = TU_HeatingLoad; // Evaporator (IU side) operational parameters - Pevap = GetSatPressureRefrig(state, this->RefrigerantName, this->IUEvaporatingTemp, RefrigerantIndex, RoutineName); + Pevap = this->refrig->getSatPressure(state, this->IUEvaporatingTemp, RoutineName); Psuction = Pevap; Tsuction = this->IUEvaporatingTemp; this->EvaporatingTemp = this->IUEvaporatingTemp; // Condenser (OU side) operation ranges CapMaxPc = min(Psuction + this->CompMaxDeltaP, RefMaxPc); - CapMaxTc = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMaxPc, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + CapMaxTc = this->refrig->getSatTemperature(state, max(min(CapMaxPc, RefPHigh), RefPLow), RoutineName); CapMinTc = OutdoorDryBulb + this->SC; - CapMinPc = GetSatPressureRefrig(state, this->RefrigerantName, CapMinTc, RefrigerantIndex, RoutineName); + CapMinPc = this->refrig->getSatPressure(state, CapMinTc, RoutineName); // Evaporator (IU side) operation ranges CapMinPe = max(CapMinPc - this->CompMaxDeltaP, RefMinPe); - CapMinTe = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(CapMinPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + CapMinTe = this->refrig->getSatTemperature(state, max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); //===**h_comp_out Iteration Starts // Initialization of h_comp_out iterations (Label230) { - Pcond = GetSatPressureRefrig(state, this->RefrigerantName, this->IUCondensingTemp, RefrigerantIndex, RoutineName); - Real64 Pcond_temp = GetSatPressureRefrig(state, this->RefrigerantName, 40.0, RefrigerantIndex, RoutineName); - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, Pcond_temp, RefrigerantIndex, RoutineName); - h_IU_cond_in_up = GetSupHeatEnthalpyRefrig( - state, this->RefrigerantName, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond_temp, RefrigerantIndex, RoutineName); - h_IU_cond_in_low = - GetSatEnthalpyRefrig(state, this->RefrigerantName, this->IUCondensingTemp, 1.0, RefrigerantIndex, RoutineName); // Quality=1 + Pcond = this->refrig->getSatPressure(state, this->IUCondensingTemp, RoutineName); + Real64 Pcond_temp = this->refrig->getSatPressure(state, 40.0, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, Pcond_temp, RoutineName); + h_IU_cond_in_up = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond_temp, RoutineName); + h_IU_cond_in_low = this->refrig->getSatEnthalpy(state, this->IUCondensingTemp, 1.0, RoutineName); // Quality=1 h_IU_cond_in = h_IU_cond_in_low; } @@ -11835,13 +11797,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) { TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex; - h_IU_cond_out_i = GetSatEnthalpyRefrig( + h_IU_cond_out_i = this->refrig->getSatEnthalpy( state, - this->RefrigerantName, - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) - + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, 0.0, - RefrigerantIndex, RoutineName); // Quality=0 m_ref_IU_cond_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) <= 0.0) @@ -11856,12 +11816,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_cond_out_ave = h_IU_cond_out_ave / m_ref_IU_cond; SC_IU_merged = SC_IU_merged / m_ref_IU_cond; } else { - h_IU_cond_out_ave = GetSatEnthalpyRefrig( + h_IU_cond_out_ave = this->refrig->getSatEnthalpy( state, - this->RefrigerantName, - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) - 5.0, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, 0.0, - RefrigerantIndex, RoutineName); // Quality=0 SC_IU_merged = 5; m_ref_IU_cond = TU_HeatingLoad / (h_IU_cond_in - h_IU_cond_out_ave); @@ -11871,7 +11829,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) this->VRFOU_PipeLossH( state, m_ref_IU_cond, max(min(Pcond, RefPHigh), RefPLow), h_IU_cond_in, OutdoorDryBulb, Pipe_Q_h, Pipe_DeltP_h, h_comp_out); Pdischarge = max(Pcond + Pipe_DeltP_h, Pcond); // affected by piping loss - Tdischarge = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pdischarge, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Tdischarge = this->refrig->getSatTemperature(state, max(min(Pdischarge, RefPHigh), RefPLow), RoutineName); Q_h_TU_PL = TU_HeatingLoad + Pipe_Q_h; // *PL-c: Calculate total IU refrigerant flow rate and SH_IU_merged @@ -11884,12 +11842,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex; - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_IU_evap_out_i = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out_i = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); if (h_IU_evap_out_i > h_IU_evap_in) { @@ -11907,12 +11863,10 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_evap_out = h_IU_evap_out / m_ref_IU_evap; SH_IU_merged = SH_IU_merged / m_ref_IU_evap; } else { - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pevap, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_IU_evap_out = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); @@ -11929,7 +11883,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Pipe_DeltP_c, h_IU_PLc_out); Psuction = min(Pevap - Pipe_DeltP_c, Pevap); // This Psuction is used for rps > min; will be updated for rps = min - Tsuction = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Psuction, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Tsuction = this->refrig->getSatTemperature(state, max(min(Psuction, RefPHigh), RefPLow), RoutineName); h_comp_in = h_IU_PLc_out; Q_c_TU_PL = TU_CoolingLoad + Pipe_Q_c; @@ -13477,13 +13431,6 @@ Real64 VRFCondenserEquipment::VRFOU_CapModFactor( // METHODOLOGY EMPLOYED: // This is part of the VRF-FluidTCtrl Model. - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSupHeatDensityRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - - int RefrigerantIndex; // Index of the refrigerant [-] Real64 C_cap_density; // Compressor capacity modification algorithm_modified flow rate [-] Real64 C_cap_enthalpy; // Compressor capacity modification algorithm_modified enthalpy difference [-] Real64 C_cap_operation; // Compressor capacity modification algorithm_modified Cap [-] @@ -13495,20 +13442,16 @@ Real64 VRFCondenserEquipment::VRFOU_CapModFactor( static constexpr std::string_view RoutineName("VRFOU_CapModFactor"); - // variable initializations - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - // Saturated temperature at real evaporating pressure - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, P_evap_real, RefrigerantIndex, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, P_evap_real, RoutineName); // Enthalpy at rated conditions - h_evap_out_rate = - GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, max(RefTSat, T_comp_in_rate), P_evap_real, RefrigerantIndex, RoutineName); - h_evap_in_rate = GetSatEnthalpyRefrig(state, this->RefrigerantName, T_cond_out_rate, 0.0, RefrigerantIndex, RoutineName); + h_evap_out_rate = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, T_comp_in_rate), P_evap_real, RoutineName); + h_evap_in_rate = this->refrig->getSatEnthalpy(state, T_cond_out_rate, 0.0, RoutineName); // Density calculations - density_rate = GetSupHeatDensityRefrig(state, this->RefrigerantName, T_comp_in_rate, P_evap_real, RefrigerantIndex, RoutineName); - density_real = GetSupHeatDensityRefrig(state, this->RefrigerantName, T_comp_in_real, P_evap_real, RefrigerantIndex, RoutineName); + density_rate = this->refrig->getSupHeatDensity(state, T_comp_in_rate, P_evap_real, RoutineName); + density_real = this->refrig->getSupHeatDensity(state, T_comp_in_real, P_evap_real, RoutineName); // Modification factor calculations if (density_real > 0) @@ -13554,15 +13497,9 @@ void VRFCondenserEquipment::VRFOU_TeModification( // METHODOLOGY EMPLOYED: // This is part of the VRF-FluidTCtrl Model. - using Fluid::FindRefrigerant; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - int CoolCoilIndex; // index to cooling coil in terminal unit int NumTUInList; // number of terminal units is list int NumTeIte; // counter for Te calculation iterations [-] - int RefrigerantIndex; // Index of the refrigerant [-] int TUListNum; // index to TU List int TUIndex; // Index to terminal unit Real64 MaxNumTeIte; // Piping Loss Algorithm Parameter: max number of iterations for Te [-] @@ -13583,9 +13520,8 @@ void VRFCondenserEquipment::VRFOU_TeModification( // variable initializations TUListNum = this->ZoneTUListPtr; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; // Initialization of Te iterations (Label11) @@ -13600,7 +13536,7 @@ Label11:; Pipe_h_IU_out_i = 0; Pipe_m_ref_i = 0; Pipe_SH_merged = 0; - Pe_update = GetSatPressureRefrig(state, this->RefrigerantName, Te_update, RefrigerantIndex, RoutineName); + Pe_update = this->refrig->getSatPressure(state, Te_update, RoutineName); // Re-calculate total refrigerant flow rate, with updated SH for (int NumTU = 1; NumTU <= NumTUInList; NumTU++) { @@ -13619,12 +13555,10 @@ Label11:; SH_IU_update = (-this->C2Te + std::pow((pow_2(this->C2Te) - 4 * (this->C1Te - Tfs + Te_update) * this->C3Te), 0.5)) / (2 * this->C3Te); - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, Pe_update, RefrigerantIndex, RoutineName); - Pipe_h_IU_out_i = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + RefTSat = this->refrig->getSatTemperature(state, Pe_update, RoutineName); + Pipe_h_IU_out_i = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, Te_update + SH_IU_update), Pe_update, - RefrigerantIndex, RoutineName); // hB_i for the IU if (Pipe_h_IU_out_i > Pipe_h_IU_in) { @@ -13642,16 +13576,14 @@ Label11:; Pipe_SH_merged = Pipe_SH_merged / Pipe_m_ref; } else { Pipe_SH_merged = this->SH; - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, Pe_update, RefrigerantIndex, RoutineName); - Pipe_h_IU_out = GetSupHeatEnthalpyRefrig( - state, this->RefrigerantName, max(RefTSat, Te_update + Pipe_SH_merged), Pe_update, RefrigerantIndex, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, Pe_update, RoutineName); + Pipe_h_IU_out = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, Te_update + Pipe_SH_merged), Pe_update, RoutineName); } // Re-calculate piping loss this->VRFOU_PipeLossC(state, Pipe_m_ref, Pe_update, Pipe_h_IU_out, Pipe_SH_merged, OutdoorDryBulb, Pipe_Q, Pipe_DeltP, Pipe_h_comp_in); - Tsuction = - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pe_update - Pipe_DeltP, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Tsuction = this->refrig->getSatTemperature(state, max(min(Pe_update - Pipe_DeltP, RefPHigh), RefPLow), RoutineName); if ((std::abs(Tsuction - Te_low) > 0.5) && (Te_update < Te_up) && (Te_update > Te_low) && (NumTeIte < MaxNumTeIte)) { Te_update = Te_update - 0.1; @@ -13692,9 +13624,6 @@ void VRFCondenserEquipment::VRFOU_CompSpd( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using Fluid::FindRefrigerant; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSupHeatTempRefrig; // Locals // SUBROUTINE ARGUMENT DEFINITIONS: @@ -13705,7 +13634,6 @@ void VRFCondenserEquipment::VRFOU_CompSpd( int CompSpdUB; // index for Compressor speed up bound [-] int NumOfCompSpdInput; // Number of compressor speed input by the user [-] int NumTUInList; // number of terminal units is list - int RefrigerantIndex; // Index of the refrigerant int TUListNum; // index to TU List Real64 C_cap_operation; // Compressor capacity modification algorithm_modified Cap [-] Real64 P_suction; // Compressor suction pressure Pe' [Pa] @@ -13723,9 +13651,8 @@ void VRFCondenserEquipment::VRFOU_CompSpd( // variable initializations: component index TUListNum = this->ZoneTUListPtr; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; // variable initializations: compressor NumOfCompSpdInput = this->CompressorSpeed.size(); @@ -13733,14 +13660,12 @@ void VRFCondenserEquipment::VRFOU_CompSpd( CompEvaporatingCAPSpd.dimension(NumOfCompSpdInput); // variable initializations: system operational parameters - P_suction = GetSatPressureRefrig(state, this->RefrigerantName, T_suction, RefrigerantIndex, RoutineName); - T_comp_in = GetSupHeatTempRefrig(state, - this->RefrigerantName, + P_suction = this->refrig->getSatPressure(state, T_suction, RoutineName); + T_comp_in = this->refrig->getSupHeatTemp(state, max(min(P_suction, RefPHigh), RefPLow), h_comp_in, T_suction + 3, T_suction + 30, - RefrigerantIndex, RoutineName); SH_Comp = T_comp_in - T_suction; @@ -13851,16 +13776,11 @@ void VRFCondenserEquipment::VRFOU_CompCap( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using Fluid::FindRefrigerant; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSupHeatTempRefrig; - int CounterCompSpdTemp; // Index for the compressor speed level[-] int CompSpdLB; // index for Compressor speed low bound [-] int CompSpdUB; // index for Compressor speed up bound [-] int NumOfCompSpdInput; // Number of compressor speed input by the user [-] int NumTUInList; // number of terminal units is list - int RefrigerantIndex; // Index of the refrigerant int TUListNum; // index to TU List Real64 C_cap_operation; // Compressor capacity modification algorithm_modified Cap [-] Real64 P_suction; // Compressor suction pressure Pe' [Pa] @@ -13877,9 +13797,8 @@ void VRFCondenserEquipment::VRFOU_CompCap( // variable initializations: component index TUListNum = this->ZoneTUListPtr; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; // variable initializations: compressor NumOfCompSpdInput = this->CompressorSpeed.size(); @@ -13923,14 +13842,12 @@ void VRFCondenserEquipment::VRFOU_CompCap( } // variable initializations: system operational parameters - P_suction = GetSatPressureRefrig(state, this->RefrigerantName, T_suction, RefrigerantIndex, RoutineName); - T_comp_in = GetSupHeatTempRefrig(state, - this->RefrigerantName, + P_suction = this->refrig->getSatPressure(state, T_suction, RoutineName); + T_comp_in = this->refrig->getSupHeatTemp(state, max(min(P_suction, RefPHigh), RefPLow), h_comp_in, T_suction + 3, T_suction + 30, - RefrigerantIndex, RoutineName); SH_Comp = T_comp_in - T_suction; @@ -13973,12 +13890,7 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - using Fluid::GetSupHeatTempRefrig; + using General::SolveRoot; int CounterCompSpdTemp; // Index for the compressor speed level[-] @@ -13990,7 +13902,6 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, int NumIteCcap; // counter for Ccap calculation iterations [-] int NumIteTe; // counter for Te calculation iterations [-] int NumTUInList; // number of terminal units is list - int RefrigerantIndex; // Index of the refrigerant [-] int SolFla; // Slove flag for SolveRoot [-] int TUListNum; // index to TU List int TUIndex; // Index to terminal unit @@ -14035,9 +13946,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, Q_evap_req = TU_load + Pipe_Q; TUListNum = this->ZoneTUListPtr; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; Modifi_SH = Pipe_T_comp_in - T_suction; @@ -14091,19 +14001,18 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, // Update the C_cap_operation Label13:; Q_evap_req = TU_load + Pipe_Q0; // Pipe_Q0 is updated during the iteration - Pipe_h_IU_in = GetSatEnthalpyRefrig(state, this->RefrigerantName, T_discharge_new - this->SC, 0.0, RefrigerantIndex, RoutineName); + Pipe_h_IU_in = this->refrig->getSatEnthalpy(state, T_discharge_new - this->SC, 0.0, RoutineName); CompSpdActual = this->CompressorSpeed(1); Real64 CondHeat = Q_evap_req * C_cap_operation0 / this->RatedEvapCapacity; // 150130 To be confirmed int CAPFT = this->OUCoolingCAPFT(CounterCompSpdTemp); // Update Te' (SmallLoadTe) to meet the required evaporator capacity MinOutdoorUnitTe = 6; - P_discharge = GetSatPressureRefrig(state, this->RefrigerantName, T_discharge, RefrigerantIndex, RoutineName); + P_discharge = this->refrig->getSatPressure(state, T_discharge, RoutineName); - MinRefriPe = GetSatPressureRefrig(state, this->RefrigerantName, -15, RefrigerantIndex, RoutineName); + MinRefriPe = this->refrig->getSatPressure(state, -15, RoutineName); MinOutdoorUnitPe = max(P_discharge - this->CompMaxDeltaP, MinRefriPe); - MinOutdoorUnitTe = GetSatTemperatureRefrig( - state, this->RefrigerantName, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + MinOutdoorUnitTe = this->refrig->getSatTemperature(state, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RoutineName); auto f = [&state, T_discharge_new, CondHeat, CAPFT](Real64 const T_suc) { return CompResidual_FluidTCtrl(state, T_discharge_new, CondHeat, CAPFT, T_suc); @@ -14132,7 +14041,7 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, Pipe_h_IU_out_i = 0; Pipe_m_ref_i = 0; Pipe_SH_merged = 0; - Pipe_Pe_assumed = GetSatPressureRefrig(state, this->RefrigerantName, Pipe_Te_assumed, RefrigerantIndex, RoutineName); + Pipe_Pe_assumed = this->refrig->getSatPressure(state, Pipe_Te_assumed, RoutineName); // Re-calculate total refrigerant flow rate, with updated SH for (int NumTU = 1; NumTU <= NumTUInList; NumTU++) { @@ -14151,13 +14060,10 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, (-this->C2Te + std::pow((pow_2(this->C2Te) - 4 * (this->C1Te - Tfs + Pipe_Te_assumed) * this->C3Te), 0.5)) / (2 * this->C3Te); - RefTSat = GetSatTemperatureRefrig( - state, this->RefrigerantName, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - Pipe_h_IU_out_i = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + RefTSat = this->refrig->getSatTemperature(state, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); + Pipe_h_IU_out_i = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, Pipe_Te_assumed + Modifi_SHin), max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); if (Pipe_h_IU_out_i > Pipe_h_IU_in) { @@ -14176,14 +14082,11 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, Pipe_SH_merged = Pipe_SH_merged / Pipe_m_ref; } else { Pipe_SH_merged = this->SH; - RefTSat = GetSatTemperatureRefrig( - state, this->RefrigerantName, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - Pipe_h_IU_out = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, - max(RefTSat, Pipe_Te_assumed + Pipe_SH_merged), - max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), - RefrigerantIndex, - RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); + Pipe_h_IU_out = this->refrig->getSupHeatEnthalpy(state, + max(RefTSat, Pipe_Te_assumed + Pipe_SH_merged), + max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), + RoutineName); } // Re-calculate piping loss @@ -14197,8 +14100,7 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, Pipe_DeltP, Pipe_h_comp_in); - T_suction = GetSatTemperatureRefrig( - state, this->RefrigerantName, max(min(Pipe_Pe_assumed - Pipe_DeltP, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + T_suction = this->refrig->getSatTemperature(state, max(min(Pipe_Pe_assumed - Pipe_DeltP, RefPHigh), RefPLow), RoutineName); if ((std::abs(T_suction - SmallLoadTe) > 0.5) && (Pipe_Te_assumed < this->EvaporatingTemp) && (Pipe_Te_assumed > SmallLoadTe) && (NumIteTe < MaxNumIteTe)) { @@ -14217,13 +14119,11 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, } // Perform iteration to calculate Pipe_T_comp_in( Te'+SH' ) - Pipe_T_comp_in = GetSupHeatTempRefrig(state, - this->RefrigerantName, + Pipe_T_comp_in = this->refrig->getSupHeatTemp(state, max(min(Pipe_Pe_assumed - Pipe_DeltP, RefPHigh), RefPLow), Pipe_h_comp_in, T_suction + 3, T_suction + 30, - RefrigerantIndex, RoutineName); Modifi_SH = Pipe_T_comp_in - T_suction; @@ -14322,12 +14222,6 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( // This is part of the VRF-FluidTCtrl Model. using Curve::CurveValue; - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; int CounterCompSpdTemp; // Index for the compressor speed level[-] @@ -14337,7 +14231,6 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( int NumOfCompSpdInput; // Number of compressor speed input by the user [-] int NumIteCcap; // counter for Ccap calculation iterations [-] int NumTUInList; // number of terminal units is list - int RefrigerantIndex; // Index of the refrigerant [-] int SolFla; // Solve flag for SolveRoot [-] int TUListNum; // index to TU List Real64 Cap_Eva0; // Evaporating capacity calculated based on physics model, used in the iterations [W] @@ -14366,19 +14259,16 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( Q_evap_req = TU_load + Pipe_Q - Ncomp; TUListNum = this->ZoneTUListPtr; - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; NumTUInList = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; // Calculate capacity modification factor - MinOutdoorUnitPe = GetSatPressureRefrig(state, this->RefrigerantName, T_suction, RefrigerantIndex, RoutineName); - RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - Pipe_h_comp_in = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, + MinOutdoorUnitPe = this->refrig->getSatPressure(state, T_suction, RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RoutineName); + Pipe_h_comp_in = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, T_suction + this->SH), max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); C_cap_operation = this->VRFOU_CapModFactor( state, Pipe_h_comp_in, Pipe_h_out_ave, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), T_suction + this->SH, T_suction + 8, IUMaxCondTemp - 5); @@ -14438,17 +14328,14 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( Modifi_SH = (-this->C2Te + std::pow((pow_2(this->C2Te) - 4 * (this->C1Te - Tfs + T_suction) * this->C3Te), 0.5)) / (2 * this->C3Te); - Modifi_Pe = GetSatPressureRefrig(state, this->RefrigerantName, T_suction, RefrigerantIndex, RoutineName); + Modifi_Pe = this->refrig->getSatPressure(state, T_suction, RoutineName); // Calculate capacity modification factor - RefTSat = - GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Modifi_Pe, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - Pipe_h_comp_in = GetSupHeatEnthalpyRefrig(state, - this->RefrigerantName, - max(RefTSat, T_suction + Modifi_SH), - max(min(Modifi_Pe, RefPHigh), RefPLow), - RefrigerantIndex, - RoutineName); + RefTSat = this->refrig->getSatTemperature(state, max(min(Modifi_Pe, RefPHigh), RefPLow), RoutineName); + Pipe_h_comp_in = this->refrig->getSupHeatEnthalpy(state, + max(RefTSat, T_suction + Modifi_SH), + max(min(Modifi_Pe, RefPHigh), RefPLow), + RoutineName); C_cap_operation = this->VRFOU_CapModFactor(state, Pipe_h_comp_in, Pipe_h_out_ave, @@ -14530,17 +14417,12 @@ void VRFCondenserEquipment::VRFHR_OU_HR_Mode(EnergyPlusData &state, // METHODOLOGY EMPLOYED: // This is part of the physics based VRF model applicable for Fluid Temperature Control. - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatPressureRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; using General::SolveRoot; Real64 constexpr ErrorTol(0.1); // tolerance for RegulaFalsi iterations int constexpr MaxIte(100); // maximum number of iterations int HRMode(0); // HR operational mode [W] int HRMode_sub(0); // HR operational mode (sub) [W] - int RefrigerantIndex; // Index of the refrigerant [-] int SolFla; // Flag of RegulaFalsi solver Real64 C_OU_HexRatio; // capacity ratio between the OU condenser and OU evaporator [-] Real64 m_air_rated; // OU coil air mass flow rate [kg/s] @@ -14570,9 +14452,8 @@ void VRFCondenserEquipment::VRFHR_OU_HR_Mode(EnergyPlusData &state, C_OU_HexRatio = this->HROUHexRatio; // Initializations: component index - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; - RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; + RefPLow = this->refrig->PsLowPresValue; + RefPHigh = this->refrig->PsHighPresValue; // **Q_OU: HR mode determination // HRMode-1. Cooling Only @@ -14914,14 +14795,13 @@ void VRFCondenserEquipment::VRFHR_OU_HR_Mode(EnergyPlusData &state, Real64 h_OU_cond_in; // enthalpy of OU condenser at inlet [kJ/kg] Real64 h_OU_cond_out; // enthalpy of OU condenser at outlet [kJ/kg] - Real64 Psuction = GetSatPressureRefrig(state, this->RefrigerantName, Tsuction, RefrigerantIndex, RoutineName); + Real64 Psuction = this->refrig->getSatPressure(state, Tsuction, RoutineName); // enthalpy of OU evaporator/condenser inlets and outlets h_OU_evap_in = h_IU_evap_in; h_OU_cond_in = h_comp_out; - h_OU_evap_out = GetSupHeatEnthalpyRefrig( - state, this->RefrigerantName, Tsuction + this->SH, max(min(Psuction, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); - h_OU_cond_out = GetSatEnthalpyRefrig(state, this->RefrigerantName, Tdischarge - this->SC, 0.0, RefrigerantIndex, RoutineName); + h_OU_evap_out = this->refrig->getSupHeatEnthalpy(state, Tsuction + this->SH, max(min(Psuction, RefPHigh), RefPLow), RoutineName); + h_OU_cond_out = this->refrig->getSatEnthalpy(state, Tdischarge - this->SC, 0.0, RoutineName); if ((Q_c_OU == 0) || (h_OU_evap_out - h_OU_evap_in) <= 0) { m_ref_OU_evap = 0; @@ -14969,8 +14849,6 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( // METHODOLOGY EMPLOYED: // Use a physics based piping loss model. - using Fluid::FindRefrigerant; - using Fluid::GetSupHeatDensityRefrig; using General::SolveRoot; int TUListNum; // index to TU List @@ -14978,7 +14856,6 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( int CoilIndex; // index to coil in terminal unit int NumTUInList; // number of terminal units is list int NumIUActivated; // number of the used indoor units [-] - int RefrigerantIndex; // Index of the refrigerant [-] Real64 Pipe_v_ref; // Piping Loss Algorithm Parameter: Refrigerant velocity [m/s] Real64 Pipe_T_room; // Piping Loss Algorithm Parameter: Average Room Temperature [C] @@ -15007,9 +14884,8 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( Pipe_cp_ref = 1.6; // Refrigerant data - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - Real64 RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - Real64 RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) + Real64 RefPLow = this->refrig->PsLowPresValue; // Low Pressure Value for Ps (>0.0) + Real64 RefPHigh = this->refrig->PsHighPresValue; // High Pressure Value for Ps (max in tables) // Calculate Pipe_T_room Pipe_T_room = 0; @@ -15041,11 +14917,9 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( if (Pipe_viscosity_ref <= 0) Pipe_viscosity_ref = 16.26; // default superheated vapor viscosity data (MuPa*s) at T=353.15 K, P=2MPa Pipe_v_ref = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaSuc) * 0.25) / - GetSupHeatDensityRefrig(state, - this->RefrigerantName, + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName); Pipe_Num_Re = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaSuc) * 0.25) * this->RefPipDiaSuc / Pipe_viscosity_ref * 1000000; Pipe_Num_Pr = Pipe_viscosity_ref * Pipe_cp_ref * 0.001 / Pipe_conductivity_ref; @@ -15054,19 +14928,15 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( Pipe_DeltP = max(0.0, 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaSuc * - GetSupHeatDensityRefrig(state, - this->RefrigerantName, + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName) * pow_2(Pipe_v_ref) / 2 - this->RefPipHei * - GetSupHeatDensityRefrig(state, - this->RefrigerantName, + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), - RefrigerantIndex, RoutineName) * 9.80665); @@ -15116,11 +14986,6 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( // METHODOLOGY EMPLOYED: // Use a physics based piping loss model. - using Fluid::FindRefrigerant; - using Fluid::GetSatTemperatureRefrig; - using Fluid::GetSupHeatDensityRefrig; - using Fluid::GetSupHeatEnthalpyRefrig; - using Fluid::GetSupHeatTempRefrig; using General::SolveRoot; int TUListNum; // index to TU List @@ -15128,7 +14993,6 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( int CoilIndex; // index to coil in terminal unit int NumTUInList; // number of terminal units is list int NumIUActivated; // number of the used indoor units [-] - int RefrigerantIndex; // Index of the refrigerant [-] Real64 Pipe_v_ref; // Piping Loss Algorithm Parameter: Refrigerant velocity [m/s] Real64 Pipe_T_room; // Piping Loss Algorithm Parameter: Average Room Temperature [C] @@ -15158,20 +15022,17 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( Pipe_cp_ref = 1.6; // Refrigerant data - RefrigerantIndex = FindRefrigerant(state, this->RefrigerantName); - Real64 RefTHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighTempValue; // High Temperature Value for Ps (max in tables) - Real64 RefPLow = state.dataFluid->RefrigData(RefrigerantIndex).PsLowPresValue; // Low Pressure Value for Ps (>0.0) - Real64 RefPHigh = state.dataFluid->RefrigData(RefrigerantIndex).PsHighPresValue; // High Pressure Value for Ps (max in tables) - Real64 RefTSat = GetSatTemperatureRefrig(state, this->RefrigerantName, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + Real64 RefTHigh = this->refrig->PsHighTempValue; // High Temperature Value for Ps (max in tables) + Real64 RefPLow = this->refrig->PsLowPresValue; // Low Pressure Value for Ps (>0.0) + Real64 RefPHigh = this->refrig->PsHighPresValue; // High Pressure Value for Ps (max in tables) + Real64 RefTSat = this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName); // Perform iteration to calculate Pipe_T_IU_in, given P and h - Pipe_T_IU_in = GetSupHeatTempRefrig(state, - this->RefrigerantName, + Pipe_T_IU_in = this->refrig->getSupHeatTemp(state, max(min(Pcond, RefPHigh), RefPLow), Pipe_h_IU_in, max(this->IUCondensingTemp, RefTSat), min(this->IUCondensingTemp + 50, RefTHigh), - RefrigerantIndex, RoutineName); Pipe_T_IU_in = min(RefTHigh, Pipe_T_IU_in); @@ -15204,7 +15065,7 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( Pipe_v_ref = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaDis) * 0.25) / - GetSupHeatDensityRefrig(state, this->RefrigerantName, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName); + this->refrig->getSupHeatDensity(state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName); Pipe_Num_Re = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaDis) * 0.25) * this->RefPipDiaDis / Pipe_viscosity_ref * 1000000; Pipe_Num_Pr = Pipe_viscosity_ref * Pipe_cp_ref * 0.001 / Pipe_conductivity_ref; Pipe_Num_Nu = 0.023 * std::pow(Pipe_Num_Re, 0.8) * std::pow(Pipe_Num_Pr, 0.4); @@ -15219,12 +15080,12 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( (1 / Pipe_Coe_k1 + 1 / Pipe_Coe_k2 + 1 / Pipe_Coe_k3)); // [W] Pipe_DeltP = max(0.0, 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaDis * - GetSupHeatDensityRefrig( - state, this->RefrigerantName, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) * + this->refrig->getSupHeatDensity( + state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * pow_2(Pipe_v_ref) / 2 - this->RefPipHei * - GetSupHeatDensityRefrig( - state, this->RefrigerantName, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RefrigerantIndex, RoutineName) * + this->refrig->getSupHeatDensity( + state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * 9.80665); Pipe_h_comp_out = Pipe_h_IU_in + Pipe_Q / Pipe_m_ref; diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh index 480aa67321a..0c964296861 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh @@ -58,6 +58,7 @@ #include #include #include +#include #include #include #include @@ -359,7 +360,8 @@ namespace HVACVariableRefrigerantFlow { Real64 OUCondHeatRate; // Outdoor Unit Condenser Heat Release Rate, excluding piping loss [W] Real64 OUEvapHeatRate; // Outdoor Unit Evaporator Heat Extract Rate, excluding piping loss [W] Real64 OUFanPower; // Outdoor unit fan power at real conditions[W] - std::string RefrigerantName; // Name of refrigerant, must match name in FluidName (see fluidpropertiesrefdata.idf) + std::string refrigName; // Name of refrigerant, must match name in FluidName (see fluidpropertiesrefdata.idf) + FluidProperties::RefrigerantData *refrig; Real64 RatedEvapCapacity; // Rated Evaporative Capacity [W] Real64 RatedHeatCapacity; // Rated Heating Capacity [W] Real64 RatedCompPower; // Rated Compressor Power [W] diff --git a/src/EnergyPlus/HWBaseboardRadiator.cc b/src/EnergyPlus/HWBaseboardRadiator.cc index d3d6f57df9e..c6ff41bfedc 100644 --- a/src/EnergyPlus/HWBaseboardRadiator.cc +++ b/src/EnergyPlus/HWBaseboardRadiator.cc @@ -880,7 +880,7 @@ namespace HWBaseboardRadiator { // Initialize WaterInletNode = HWBaseboard.WaterInletNode; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidIndex, @@ -892,7 +892,7 @@ namespace HWBaseboardRadiator { state.dataLoopNodes->Node(WaterInletNode).Temp = 60.0; - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(WaterInletNode).Temp, state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1068,12 +1068,12 @@ namespace HWBaseboardRadiator { CheckZoneSizing(state, cCMO_BBRadiator_Water, hWBaseboard.Name); DesCoilLoad = RatedCapacityDes; if (DesCoilLoad >= HVAC::SmallLoad) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, RoutineName); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1120,7 +1120,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; } else if (hWBaseboard.RatedCapacity == DataSizing::AutoSize || hWBaseboard.RatedCapacity == 0.0) { DesCoilLoad = RatedCapacityDes; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1132,7 +1132,7 @@ namespace HWBaseboardRadiator { // Air mass flow rate is obtained from the following linear equation // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, hWBaseboard.WaterTempAvg, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1188,7 +1188,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, hWBaseboard.WaterTempAvg, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, @@ -1293,7 +1293,7 @@ namespace HWBaseboardRadiator { // Calculate air mass flow rate AirMassFlowRate = hWBaseboard.AirMassFlowRateStd * (WaterMassFlowRate / hWBaseboard.WaterMassFlowRateMax); CapacitanceAir = Psychrometrics::PsyCpAirFnW(hWBaseboard.AirInletHumRat) * AirMassFlowRate; - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidName, WaterInletTemp, state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc index 7dfb18e22e5..db7141f1015 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc @@ -359,7 +359,7 @@ void GetGshpInput(EnergyPlusData &state) ShowFatalError(state, "Errors Found in getting Gshp input"); } - state.dataHPWaterToWaterClg->GSHPRefrigIndex = Fluid::FindRefrigerant(state, GSHPRefrigerant); + state.dataHPWaterToWaterClg->GSHPRefrigIndex = FluidProperties::GetRefrigNum(state, GSHPRefrigerant); if (state.dataHPWaterToWaterClg->GSHPRefrigIndex == 0) { ShowFatalError(state, format("Refrigerant for {} not found, should have been={}", ModuleCompName, GSHPRefrigerant)); ShowFatalError(state, format("FluidProperties:* objects for {} must be included in the idf file.", GSHPRefrigerant)); @@ -489,7 +489,7 @@ void GshpPeCoolingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -498,7 +498,7 @@ void GshpPeCoolingSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -660,13 +660,13 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) initialQLoad = 0.0; IterationCount = 0; - CpSourceSide = Fluid::GetSpecificHeatGlycol(state, + CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, this->SourceSideWaterInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - CpLoadSide = Fluid::GetSpecificHeatGlycol(state, + CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, this->LoadSideWaterInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -689,9 +689,9 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) this->SourceSideWaterInletTemp + initialQSource / (SourceSideEffect * CpSourceSide * this->SourceSideWaterMassFlowRate); // Determine the evaporating and condensing pressures - SourceSidePressure = Fluid::GetSatPressureRefrig( + SourceSidePressure = FluidProperties::GetSatPressureRefrig( state, GSHPRefrigerant, SourceSideRefridgTemp, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineName); - LoadSidePressure = Fluid::GetSatPressureRefrig( + LoadSidePressure = FluidProperties::GetSatPressureRefrig( state, GSHPRefrigerant, LoadSideRefridgTemp, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineName); if (SourceSidePressure < this->LowPressCutoff) { @@ -738,11 +738,11 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the Source Side Outlet Enthalpy qual = 1.0; - LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, GSHPRefrigerant, LoadSideRefridgTemp, qual, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameLoadSideRefridgTemp); qual = 0.0; - SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, GSHPRefrigerant, SourceSideRefridgTemp, qual, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameSourceSideRefridgTemp); // Determine Load Side Outlet Enthalpy @@ -750,7 +750,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) CompressInletTemp = LoadSideRefridgTemp + this->SuperheatTemp; // Determine the enathalpy of the super heated fluid at Source Side outlet - SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig( + SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompressInletTemp, LoadSidePressure, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompressInletTemp); // Determining the suction state of the fluid from inlet state involves interation @@ -759,7 +759,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached // this routine was reenginerred from HVACsim + takes pressure in Pascals, tolrance, refrgerant # R22 =6 - CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( + CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( state, GSHPRefrigerant, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameSuctionPr); T110 = CompSuctionSatTemp; @@ -769,7 +769,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) while (true) { CompSuctionTemp = 0.5 * (T110 + T111); - CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( + CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); if (std::abs(CompSuctionEnth - SuperHeatEnth) / SuperHeatEnth < 0.0001) { @@ -785,7 +785,7 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) LOOP_exit:; // Determine the Mass flow rate of refrigerant - CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( + CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterClg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); MassRef = this->CompPistonDisp * CompSuctionDensity * (1 + this->CompClearanceFactor - this->CompClearanceFactor * std::pow(DischargePr / SuctionPr, 1 / gamma)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc index e3428d2a5cb..b2448cc8586 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc @@ -349,7 +349,7 @@ void GetGshpInput(EnergyPlusData &state) ShowFatalError(state, format("Errors Found in getting {} Input", ModuleCompNameUC)); } - state.dataHPWaterToWaterHtg->GSHPRefrigIndex = Fluid::FindRefrigerant(state, GSHPRefrigerant); + state.dataHPWaterToWaterHtg->GSHPRefrigIndex = FluidProperties::GetRefrigNum(state, GSHPRefrigerant); if (state.dataHPWaterToWaterHtg->GSHPRefrigIndex == 0) { ShowFatalError(state, format("Refrigerant for {} not found, should have been={}", ModuleCompName, GSHPRefrigerant)); } @@ -479,7 +479,7 @@ void GshpPeHeatingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -488,7 +488,7 @@ void GshpPeHeatingSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -613,13 +613,13 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) Real64 initialQLoad = 0.0; int IterationCount = 0; - Real64 CpSourceSide = Fluid::GetSpecificHeatGlycol(state, + Real64 CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, this->SourceSideWaterInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpLoadSide = Fluid::GetSpecificHeatGlycol(state, + Real64 CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, this->LoadSideWaterInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -640,9 +640,9 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) Real64 LoadSideTemp = this->LoadSideWaterInletTemp + initialQLoad / (LoadSideEffect * CpLoadSide * this->LoadSideWaterMassFlowRate); // Determine the evaporating and condensing pressures - Real64 SourceSidePressure = Fluid::GetSatPressureRefrig( + Real64 SourceSidePressure = FluidProperties::GetSatPressureRefrig( state, GSHPRefrigerant, SourceSideTemp, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSourceSideTemp); - Real64 LoadSidePressure = Fluid::GetSatPressureRefrig( + Real64 LoadSidePressure = FluidProperties::GetSatPressureRefrig( state, GSHPRefrigerant, LoadSideTemp, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameLoadSideTemp); // check cutoff pressures @@ -682,18 +682,18 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the Source Side Outlet Enthalpy Real64 qualOne = 1.0; - Real64 SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + Real64 SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, GSHPRefrigerant, SourceSideTemp, qualOne, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSourceSideTemp); // Determine Load Side Outlet Enthalpy Real64 qualZero = 0.0; - Real64 LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + Real64 LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, GSHPRefrigerant, LoadSideTemp, qualZero, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameLoadSideTemp); // Determine superheated temperature of the Source Side outlet/compressor inlet Real64 CompressInletTemp = SourceSideTemp + this->SuperheatTemp; // Determine the enathalpy of the super heated fluid at Source Side outlet - Real64 SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, + Real64 SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, GSHPRefrigerant, CompressInletTemp, SourceSidePressure, @@ -705,7 +705,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) // Determine the saturated temp at suction pressure, shoot out into the superheated region find the enthalpy // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached - CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( + CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( state, GSHPRefrigerant, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameSuctionPr); Real64 T110 = CompSuctionSatTemp; @@ -716,7 +716,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) while (true) { CompSuctionTemp = 0.5 * (T110 + T111); - CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( + CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); if (std::abs(CompSuctionEnth - SuperHeatEnth) / SuperHeatEnth < 0.0001) { break; @@ -730,7 +730,7 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) } // Determine the Mass flow rate of refrigerant - CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( + CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig( state, GSHPRefrigerant, CompSuctionTemp, SuctionPr, state.dataHPWaterToWaterHtg->GSHPRefrigIndex, RoutineNameCompSuctionTemp); Real64 MassRef = this->CompPistonDisp * CompSuctionDensity * (1.0 + this->CompClearanceFactor - this->CompClearanceFactor * std::pow(DischargePr / SuctionPr, 1.0 / gamma)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc index ba04b7dfaf5..ec365e8c315 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc @@ -729,26 +729,26 @@ void GshpSpecs::InitWatertoWaterHP(EnergyPlusData &state, this->MustRun = true; if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFHeating) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowHeat * rho; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); this->SourceSideDesignMassFlow = this->RatedSourceVolFlowHeat * rho; } else if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFCooling) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowCool * rho; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -881,12 +881,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) // store flow rate right away regardless of PlantFirstSizesOkayToFinalize so that data are available this->RatedLoadVolFlowCool = tmpLoadSideVolFlowRate; } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -894,12 +894,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) tmpCoolingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else if (this->companionIdentified && this->RatedLoadVolFlowHeat > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1069,12 +1069,12 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) if (!this->ratedLoadVolFlowCoolWasAutoSized) tmpLoadSideVolFlowRate = this->RatedLoadVolFlowCool; int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1237,12 +1237,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) // PlantFirstSizesOkayToFinalize is true this->RatedLoadVolFlowHeat = tmpLoadSideVolFlowRate; } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1250,12 +1250,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) tmpHeatingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else if (this->companionIdentified && this->RatedLoadVolFlowCool > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowCool; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, @@ -1424,12 +1424,12 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) if (!this->ratedLoadVolFlowHeatWasAutoSized) tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1622,13 +1622,13 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My return; } - rhoLoadSide = Fluid::GetDensityGlycol(state, + rhoLoadSide = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - rhoSourceSide = Fluid::GetDensityGlycol(state, + rhoSourceSide = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1697,13 +1697,13 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = Fluid::GetSpecificHeatGlycol(state, + CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - CpSourceSide = Fluid::GetSpecificHeatGlycol(state, + CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1786,13 +1786,13 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My if (!this->MustRun) { return; } - rhoLoadSide = Fluid::GetDensityGlycol(state, + rhoLoadSide = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - rhoSourceSide = Fluid::GetDensityGlycol(state, + rhoSourceSide = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, @@ -1860,13 +1860,13 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = Fluid::GetSpecificHeatGlycol(state, + CpLoadSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidName, LoadSideInletTemp, state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).FluidIndex, RoutineName); - CpSourceSide = Fluid::GetSpecificHeatGlycol(state, + CpSourceSide = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidName, SourceSideInletTemp, state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Humidifiers.cc b/src/EnergyPlus/Humidifiers.cc index e6839367170..4331a105300 100644 --- a/src/EnergyPlus/Humidifiers.cc +++ b/src/EnergyPlus/Humidifiers.cc @@ -721,10 +721,8 @@ namespace Humidifiers { // Using/Aliasing using DataSizing::AutoSize; - using Fluid::FindGlycol; - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSatEnthalpyRefrig; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyRhoAirFnPbTdbW; using Psychrometrics::RhoH2O; @@ -880,8 +878,8 @@ namespace Humidifiers { } NomCap = RhoH2O(Constant::InitConvTemp) * NomCapVol; - RefrigerantIndex = FindRefrigerant(state, format(fluidNameSteam)); - WaterIndex = FindGlycol(state, format(fluidNameWater)); + RefrigerantIndex = FluidProperties::GetRefrigNum(state, format(fluidNameSteam)); + WaterIndex = FluidProperties::GetGlycolNum(state, format(fluidNameWater)); SteamSatEnthalpy = GetSatEnthalpyRefrig(state, format(fluidNameSteam), TSteam, 1.0, RefrigerantIndex, CalledFrom); WaterSatEnthalpy = GetSatEnthalpyRefrig(state, format(fluidNameSteam), TSteam, 0.0, RefrigerantIndex, CalledFrom); WaterSpecHeatAvg = 0.5 * (GetSpecificHeatGlycol(state, format(fluidNameWater), TSteam, WaterIndex, CalledFrom) + @@ -1164,10 +1162,8 @@ namespace Humidifiers { // Using/Aliasing using Curve::CurveValue; - using Fluid::FindGlycol; - using Fluid::FindRefrigerant; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSatEnthalpyRefrig; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyTdbFnHW; using Psychrometrics::PsyWFnTdbRhPb; @@ -1256,8 +1252,8 @@ namespace Humidifiers { CurMakeupWaterTemp = state.dataEnvrn->WaterMainsTemp; } Tref = CurMakeupWaterTemp; - RefrigerantIndex = FindRefrigerant(state, format(fluidNameSteam)); - WaterIndex = FindGlycol(state, format(fluidNameWater)); + RefrigerantIndex = FluidProperties::GetRefrigNum(state, format(fluidNameSteam)); + WaterIndex = FluidProperties::GetGlycolNum(state, format(fluidNameWater)); SteamSatEnthalpy = GetSatEnthalpyRefrig(state, format(fluidNameSteam), TSteam, 1.0, RefrigerantIndex, RoutineName); WaterSatEnthalpy = GetSatEnthalpyRefrig(state, format(fluidNameSteam), TSteam, 0.0, RefrigerantIndex, RoutineName); WaterSpecHeatAvg = 0.5 * (GetSpecificHeatGlycol(state, format(fluidNameWater), TSteam, WaterIndex, RoutineName) + diff --git a/src/EnergyPlus/ICEngineElectricGenerator.cc b/src/EnergyPlus/ICEngineElectricGenerator.cc index ba63156289e..0a69998a723 100644 --- a/src/EnergyPlus/ICEngineElectricGenerator.cc +++ b/src/EnergyPlus/ICEngineElectricGenerator.cc @@ -748,7 +748,7 @@ namespace ICEngineElectricGenerator { HRecRatio = 1.0; Real64 HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 HeatRecCp = Fluid::GetSpecificHeatGlycol(state, + Real64 HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -876,7 +876,7 @@ namespace ICEngineElectricGenerator { if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/IceThermalStorage.cc b/src/EnergyPlus/IceThermalStorage.cc index ab0392f0cd2..7b1aed106ae 100644 --- a/src/EnergyPlus/IceThermalStorage.cc +++ b/src/EnergyPlus/IceThermalStorage.cc @@ -224,7 +224,7 @@ namespace IceThermalStorage { } Real64 DemandMdot = this->DesignMassFlowRate; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TempIn, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -361,7 +361,7 @@ namespace IceThermalStorage { } // Calculate the current load on the ice storage unit - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, TempIn, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1688,7 +1688,7 @@ namespace IceThermalStorage { //---------------------------- int loopNum = this->plantLoc.loopNum; - Real64 CpFluid = Fluid::GetDensityGlycol(state, + Real64 CpFluid = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(loopNum).FluidName, state.dataLoopNodes->Node(this->PltInletNodeNum).Temp, state.dataPlnt->PlantLoop(loopNum).FluidIndex, diff --git a/src/EnergyPlus/LowTempRadiantSystem.cc b/src/EnergyPlus/LowTempRadiantSystem.cc index 3a7834158af..98d926fd018 100644 --- a/src/EnergyPlus/LowTempRadiantSystem.cc +++ b/src/EnergyPlus/LowTempRadiantSystem.cc @@ -272,7 +272,6 @@ namespace LowTempRadiantSystem { using DataSizing::FractionOfAutosizedCoolingCapacity; using DataSizing::FractionOfAutosizedHeatingCapacity; using DataSizing::HeatingDesignCapacity; - using Fluid::FindGlycol; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; @@ -376,7 +375,7 @@ namespace LowTempRadiantSystem { state.dataLowTempRadSys->HydrRadSys.allocate(state.dataLowTempRadSys->NumOfHydrLowTempRadSys); if (state.dataLowTempRadSys->NumOfHydrLowTempRadSys > 0) { - GlycolIndex = FindGlycol(state, fluidNameWater); + GlycolIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); for (auto &e : state.dataLowTempRadSys->HydrRadSys) e.GlycolIndex = GlycolIndex; if (GlycolIndex == 0) { @@ -390,7 +389,7 @@ namespace LowTempRadiantSystem { state.dataLowTempRadSys->CFloRadSys.allocate(state.dataLowTempRadSys->NumOfCFloLowTempRadSys); if (state.dataLowTempRadSys->NumOfCFloLowTempRadSys > 0) { - GlycolIndex = FindGlycol(state, fluidNameWater); + GlycolIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); for (auto &e : state.dataLowTempRadSys->CFloRadSys) e.GlycolIndex = GlycolIndex; if (GlycolIndex == 0) { @@ -1904,7 +1903,7 @@ namespace LowTempRadiantSystem { using DataSizing::AutoSize; using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -2633,8 +2632,8 @@ namespace LowTempRadiantSystem { // Using/Aliasing using namespace DataSizing; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using HVAC::AutoCalculateSizing; using HVAC::CoolingCapacitySizing; using HVAC::HeatingCapacitySizing; @@ -4181,7 +4180,7 @@ namespace LowTempRadiantSystem { // Using/Aliasing using DataHeatBalance::ZoneData; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using HVAC::SmallLoad; using PlantUtilities::SetComponentFlowRate; using ScheduleManager::GetCurrentScheduleValue; @@ -4691,7 +4690,7 @@ namespace LowTempRadiantSystem { auto &Zone = state.dataHeatBal->Zone; // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; // SUBROUTINE PARAMETER DEFINITIONS: @@ -5328,7 +5327,7 @@ namespace LowTempRadiantSystem { { // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; using PlantUtilities::SetComponentFlowRate; @@ -5414,7 +5413,7 @@ namespace LowTempRadiantSystem { { // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; using PlantUtilities::SetComponentFlowRate; @@ -5645,7 +5644,7 @@ namespace LowTempRadiantSystem { // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; // Return value Real64 calculateHXEffectivenessTerm; @@ -5980,7 +5979,7 @@ namespace LowTempRadiantSystem { // Using/Aliasing Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; constexpr std::string_view routineName("ReportConstantFlowSystem"); Real64 cpFluid; // Specific heat of the fluid in the radiant system diff --git a/src/EnergyPlus/MicroCHPElectricGenerator.cc b/src/EnergyPlus/MicroCHPElectricGenerator.cc index 73aeffcbd11..409b3df0f3c 100644 --- a/src/EnergyPlus/MicroCHPElectricGenerator.cc +++ b/src/EnergyPlus/MicroCHPElectricGenerator.cc @@ -696,7 +696,7 @@ void MicroCHPDataStruct::onInitLoopEquip(EnergyPlusData &state, const EnergyPlus { static constexpr std::string_view RoutineName("MicroCHPDataStruct::onInitLoopEquip"); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->PlantInletNodeID).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1165,7 +1165,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s Teng = FuncDetermineEngineTemp( TcwOut, this->A42Model.MCeng, this->A42Model.UAhx, this->A42Model.UAskin, thisAmbientTemp, Qgenss, this->A42Model.TengLast, dt); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1382,7 +1382,7 @@ void MicroCHPDataStruct::CalcUpdateHeatRecovery(EnergyPlusData &state) const state.dataLoopNodes->Node(this->PlantOutletNodeID).Temp = this->A42Model.TcwOut; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, this->A42Model.TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1417,7 +1417,7 @@ void MicroCHPDataStruct::UpdateMicroCHPGeneratorRecords(EnergyPlusData &state) / this->A42Model.ACEnergyGen = this->A42Model.Pnet * state.dataHVACGlobal->TimeStepSysSec; // energy produced (J) this->A42Model.QdotHX = this->A42Model.UAhx * (this->A42Model.Teng - this->A42Model.TcwOut); // heat recovered rate (W) - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, this->A42Model.TcwIn, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/MicroturbineElectricGenerator.cc b/src/EnergyPlus/MicroturbineElectricGenerator.cc index bcff2b46c84..7fec013cf98 100644 --- a/src/EnergyPlus/MicroturbineElectricGenerator.cc +++ b/src/EnergyPlus/MicroturbineElectricGenerator.cc @@ -1251,7 +1251,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, if (this->HeatRecActive) { HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - HeatRecCp = Fluid::GetSpecificHeatGlycol(state, + HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1585,7 +1585,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, // Calculate heat recovery rate modifier curve output (function of water [volumetric] flow rate) if (this->HeatRecRateFWaterFlowCurveNum > 0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, HeatRecInTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1958,7 +1958,7 @@ void MTGeneratorSpecs::oneTimeInit(EnergyPlusData &state) if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/NodeInputManager.cc b/src/EnergyPlus/NodeInputManager.cc index e60b130c2e9..e2203396fc8 100644 --- a/src/EnergyPlus/NodeInputManager.cc +++ b/src/EnergyPlus/NodeInputManager.cc @@ -967,10 +967,10 @@ void CalcMoreNodeInfo(EnergyPlusData &state) // stored in MoreNodeInfo. // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::CPCW; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; @@ -1031,7 +1031,7 @@ void CalcMoreNodeInfo(EnergyPlusData &state) for (int iNode = 1; iNode <= state.dataLoopNodes->NumOfNodes; ++iNode) { nodeReportingStrings.push_back(std::string(NodeReportingCalc + state.dataLoopNodes->NodeID(iNode))); - nodeFluidNames.push_back(Fluid::GetGlycolNameByIndex(state, state.dataLoopNodes->Node(iNode).FluidIndex)); + nodeFluidNames.push_back(FluidProperties::GetGlycolNameByIndex(state, state.dataLoopNodes->Node(iNode).FluidIndex)); for (auto const *reqVar : state.dataOutputProcessor->reqVars) { if (Util::SameString(reqVar->key, state.dataLoopNodes->NodeID(iNode)) || reqVar->key.empty()) { @@ -1143,7 +1143,7 @@ void CalcMoreNodeInfo(EnergyPlusData &state) } else if (state.dataLoopNodes->Node(iNode).FluidType == DataLoopNode::NodeFluidType::Water) { if (!((state.dataLoopNodes->Node(iNode).FluidIndex > 0) && - (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluid->NumOfGlycols))) { + (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluidProperties->NumOfGlycols))) { rho = RhoWaterStdInit; rhoStd = RhoWaterStdInit; Cp = CPCW(state.dataLoopNodes->Node(iNode).Temp); diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index 9a59cb708d1..afb905ad6e3 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -217,7 +217,6 @@ namespace OutdoorAirUnit { // Using/Aliasing using BranchNodeConnections::SetUpCompSets; using BranchNodeConnections::TestCompSet; - using Fluid::FindRefrigerant; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; using SteamCoils::GetCoilAirInletNode; @@ -718,7 +717,7 @@ namespace OutdoorAirUnit { thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0; // below: no extra error needed if steam properties not in input // file because getting the steam coil will have done that. - thisOutAirUnit.OAEquip(CompNum).FluidIndex = FindRefrigerant(state, "Steam"); + thisOutAirUnit.OAEquip(CompNum).FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); break; } case CompType::WaterCoil_DetailedCool: { @@ -1115,7 +1114,7 @@ namespace OutdoorAirUnit { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1285,7 +1284,7 @@ namespace OutdoorAirUnit { thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow = GetCoilMaxSteamFlowRate(state, thisOutAirUnit.OAEquip(compLoop).ComponentIndex, errFlag); Real64 const rho = - Fluid::GetSatDensityRefrig(state, + FluidProperties::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidName, Constant::SteamInitConvTemp, 1.0, diff --git a/src/EnergyPlus/OutsideEnergySources.cc b/src/EnergyPlus/OutsideEnergySources.cc index bc45d174aa0..452a0703452 100644 --- a/src/EnergyPlus/OutsideEnergySources.cc +++ b/src/EnergyPlus/OutsideEnergySources.cc @@ -371,19 +371,19 @@ void OutsideEnergySourceSpecs::size(EnergyPlusData &state) if (this->EnergyType == DataPlant::PlantEquipmentType::PurchChilledWater || this->EnergyType == DataPlant::PlantEquipmentType::PurchHotWater) { Real64 const rho = - Fluid::GetDensityGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); + FluidProperties::GetDensityGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); Real64 const Cp = - Fluid::GetSpecificHeatGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); + FluidProperties::GetSpecificHeatGlycol(state, loop.FluidName, Constant::InitConvTemp, loop.FluidIndex, format("Size {}", typeName)); NomCapDes = Cp * rho * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate; } else { // this->EnergyType == DataPlant::TypeOf_PurchSteam - Real64 const tempSteam = Fluid::GetSatTemperatureRefrig( + Real64 const tempSteam = FluidProperties::GetSatTemperatureRefrig( state, loop.FluidName, state.dataEnvrn->StdBaroPress, loop.FluidIndex, format("Size {}", typeName)); Real64 const rhoSteam = - Fluid::GetSatDensityRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); + FluidProperties::GetSatDensityRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const EnthSteamDry = - Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); + FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 1.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const EnthSteamWet = - Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 0.0, loop.FluidIndex, format("Size {}", typeName)); + FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, tempSteam, 0.0, loop.FluidIndex, format("Size {}", typeName)); Real64 const LatentHeatSteam = EnthSteamDry - EnthSteamWet; NomCapDes = rhoSteam * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate * LatentHeatSteam; } @@ -474,7 +474,7 @@ void OutsideEnergySourceSpecs::calculate(EnergyPlusData &state, bool runFlag, Re if ((this->MassFlowRate > 0.0) && runFlag) { if (this->EnergyType == DataPlant::PlantEquipmentType::PurchChilledWater || this->EnergyType == DataPlant::PlantEquipmentType::PurchHotWater) { - Real64 const Cp = Fluid::GetSpecificHeatGlycol( + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); this->OutletTemp = (MyLoad + this->MassFlowRate * Cp * this->InletTemp) / (this->MassFlowRate * Cp); // apply loop limits on temperature result to keep in check @@ -489,11 +489,11 @@ void OutsideEnergySourceSpecs::calculate(EnergyPlusData &state, bool runFlag, Re } else if (this->EnergyType == DataPlant::PlantEquipmentType::PurchSteam) { // determine mass flow rate based on inlet temp, saturate temp at // atmospheric pressure, Cp of inlet condensate, and MyLoad Real64 SatTempAtmPress = - Fluid::GetSatTemperatureRefrig(state, loop.FluidName, DataEnvironment::StdPressureSeaLevel, loop.FluidIndex, RoutineName); - Real64 CpCondensate = Fluid::GetSpecificHeatGlycol(state, loop.FluidName, this->InletTemp, loop.FluidIndex, RoutineName); + FluidProperties::GetSatTemperatureRefrig(state, loop.FluidName, DataEnvironment::StdPressureSeaLevel, loop.FluidIndex, RoutineName); + Real64 CpCondensate = FluidProperties::GetSpecificHeatGlycol(state, loop.FluidName, this->InletTemp, loop.FluidIndex, RoutineName); Real64 deltaTsensible = SatTempAtmPress - this->InletTemp; - Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 1.0, loop.FluidIndex, RoutineName); - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 0.0, loop.FluidIndex, RoutineName); + Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 1.0, loop.FluidIndex, RoutineName); + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, loop.FluidName, this->InletTemp, 0.0, loop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; this->MassFlowRate = MyLoad / (LatentHeatSteam + (CpCondensate * deltaTsensible)); PlantUtilities::SetComponentFlowRate(state, this->MassFlowRate, this->InletNodeNum, this->OutletNodeNum, this->plantLoc); diff --git a/src/EnergyPlus/PackagedThermalStorageCoil.cc b/src/EnergyPlus/PackagedThermalStorageCoil.cc index 94567c790e4..c56067863b8 100644 --- a/src/EnergyPlus/PackagedThermalStorageCoil.cc +++ b/src/EnergyPlus/PackagedThermalStorageCoil.cc @@ -198,10 +198,9 @@ void GetTESCoilInput(EnergyPlusData &state) // Using/Aliasing using BranchNodeConnections::TestCompSet; using DataZoneEquipment::FindControlledZoneIndexFromSystemNodeNumberForZone; - using Fluid::CheckFluidPropertyName; - using Fluid::FindGlycol; - using Fluid::GetFluidDensityTemperatureLimits; - using Fluid::GetFluidSpecificHeatTemperatureLimits; + using FluidProperties::CheckFluidPropertyName; + using FluidProperties::GetFluidDensityTemperatureLimits; + using FluidProperties::GetFluidSpecificHeatTemperatureLimits; using GlobalNames::VerifyUniqueCoilName; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::GetScheduleIndex; @@ -286,7 +285,7 @@ void GetTESCoilInput(EnergyPlusData &state) break; case MediaType::Water: thisTESCoil.StorageFluidName = "WATER"; - thisTESCoil.StorageFluidIndex = FindGlycol(state, "WATER"); + thisTESCoil.StorageFluidIndex = FluidProperties::GetGlycolNum(state, "WATER"); break; default: ShowSevereError(state, format("{}{}=\"{}\", invalid", RoutineName, cCurrentModuleObject, thisTESCoil.Name)); @@ -304,7 +303,7 @@ void GetTESCoilInput(EnergyPlusData &state) state, format("Check that fluid property data have been input for fluid name = {}", state.dataIPShortCut->cAlphaArgs(6))); ErrorsFound = true; } else { - thisTESCoil.StorageFluidIndex = FindGlycol(state, state.dataIPShortCut->cAlphaArgs(6)); + thisTESCoil.StorageFluidIndex = FluidProperties::GetGlycolNum(state, state.dataIPShortCut->cAlphaArgs(6)); if (thisTESCoil.StorageFluidIndex == 0) { ShowSevereError(state, format("{}{}=\"{}\", invalid fluid data", RoutineName, cCurrentModuleObject, thisTESCoil.Name)); ShowContinueError(state, @@ -2145,8 +2144,8 @@ void SizeTESCoil(EnergyPlusData &state, int &TESCoilNum) // Using/Aliasing using namespace DataSizing; using namespace OutputReportPredefined; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("SizeTESCoil "); @@ -2771,8 +2770,8 @@ void CalcTESCoilCoolingAndChargeMode(EnergyPlusData &state, // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3181,8 +3180,8 @@ void CalcTESCoilCoolingAndDischargeMode(EnergyPlusData &state, // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3528,8 +3527,8 @@ void CalcTESCoilChargeOnlyMode(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("CalcTESCoilChargeOnlyMode"); @@ -3692,8 +3691,8 @@ void CalcTESCoilDischargeOnlyMode(EnergyPlusData &state, int const TESCoilNum, R // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIter(30); @@ -3994,8 +3993,8 @@ void CalcTESWaterStorageTank(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using WaterThermalTanks::WaterThermalTankData; auto &thisTESCoil = state.dataPackagedThermalStorageCoil->TESCoil(TESCoilNum); @@ -4104,7 +4103,7 @@ void CalcTESIceStorageTank(EnergyPlusData &state, int const TESCoilNum) // Using/Aliasing Real64 const TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: constexpr Real64 FreezingTemp(0.0); // zero degrees C diff --git a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc index eda0d2ed155..1dcca089a10 100644 --- a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc +++ b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc @@ -701,7 +701,7 @@ namespace PhotovoltaicThermalCollectors { switch (this->WorkingFluidType) { case WorkingFluidEnum::LIQUID: { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->WPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->WPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PipeHeatTransfer.cc b/src/EnergyPlus/PipeHeatTransfer.cc index 57b34133931..f8761f3275c 100644 --- a/src/EnergyPlus/PipeHeatTransfer.cc +++ b/src/EnergyPlus/PipeHeatTransfer.cc @@ -942,8 +942,8 @@ void PipeHTData::InitPipesHeatTransfer(EnergyPlusData &state, bool const FirstHV // Using/Aliasing Real64 SysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using ScheduleManager::GetCurrentScheduleValue; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1713,8 +1713,8 @@ Real64 PipeHTData::CalcPipeHeatTransCoef(EnergyPlusData &state, // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using Fluid::GetConductivityGlycol; - using Fluid::GetViscosityGlycol; + using FluidProperties::GetConductivityGlycol; + using FluidProperties::GetViscosityGlycol; // Return value Real64 CalcPipeHeatTransCoef; diff --git a/src/EnergyPlus/Plant/EquipAndOperations.cc b/src/EnergyPlus/Plant/EquipAndOperations.cc index 80df453c7b4..96d2871e845 100644 --- a/src/EnergyPlus/Plant/EquipAndOperations.cc +++ b/src/EnergyPlus/Plant/EquipAndOperations.cc @@ -883,7 +883,7 @@ namespace DataPlant { // Calculate load on primary chilled water loop and store in PrimaryPlantCoolingLoad Real64 CW_RetMdot = state.dataLoopNodes->Node(this->PlantOps.PrimaryChWLoopSupInletNode).MassFlowRate; - Real64 const CpCW = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpCW = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryChWLoopIndex).FluidName, state.dataLoopNodes->Node(this->PlantOps.PrimaryChWLoopSupInletNode).Temp, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryChWLoopIndex).FluidIndex, @@ -899,7 +899,7 @@ namespace DataPlant { // int HWSupInletNode = this->PlantOps.PrimaryHWLoopSupInletNode; // state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).LoopSide(DataPlant::LoopSideLocation::Supply).Branch(1).NodeNumIn; Real64 HW_RetMdot = state.dataLoopNodes->Node(this->PlantOps.PrimaryHWLoopSupInletNode).MassFlowRate; - Real64 const CpHW = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpHW = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).FluidName, state.dataLoopNodes->Node(this->PlantOps.PrimaryHWLoopSupInletNode).Temp, state.dataPlnt->PlantLoop(this->PlantOps.PrimaryHWLoopIndex).FluidIndex, @@ -1372,7 +1372,7 @@ namespace DataPlant { // step 2. calculate the loads to adjust the // returns to hit the associated setpoints at their current mass flow Real64 const CpCW = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DedicatedHR_HeatingPLHP.sourceSidePlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(inletChWReturnNodeNum).Temp, state.dataPlnt->PlantLoop(this->DedicatedHR_HeatingPLHP.sourceSidePlantLoc.loopNum).FluidIndex, @@ -1381,7 +1381,7 @@ namespace DataPlant { CW_RetMdot * CpCW * (this->Setpoint.SecCW - state.dataLoopNodes->Node(inletChWReturnNodeNum).Temp); // power = Mdot Cp Delta T, cooling load is negative Real64 const CpHW = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DedicatedHR_CoolingPLHP.sourceSidePlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(inletHWReturnNodeNum).Temp, state.dataPlnt->PlantLoop(this->DedicatedHR_CoolingPLHP.sourceSidePlantLoc.loopNum).FluidIndex, @@ -1605,7 +1605,7 @@ namespace DataPlant { Real64 Mdot = state.dataLoopNodes->Node(inletBoilerNodeNum).MassFlowRate; Real64 const CpHW = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->PlantBoilerComps(BoilerNum).loopNum).FluidName, Tin, state.dataPlnt->PlantLoop(this->PlantBoilerComps(BoilerNum).loopNum).FluidIndex, diff --git a/src/EnergyPlus/Plant/Loop.cc b/src/EnergyPlus/Plant/Loop.cc index 167eaeeac85..b186a777718 100644 --- a/src/EnergyPlus/Plant/Loop.cc +++ b/src/EnergyPlus/Plant/Loop.cc @@ -133,7 +133,7 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) if (this->FluidType == DataLoopNode::NodeFluidType::Water) { - Cp = Fluid::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); switch (this->LoopDemandCalcScheme) { case DataPlant::LoopDemandCalcScheme::SingleSetPoint: { @@ -177,7 +177,7 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) } else if (this->FluidType == DataLoopNode::NodeFluidType::Steam) { - Cp = Fluid::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); switch (this->LoopDemandCalcScheme) { case DataPlant::LoopDemandCalcScheme::SingleSetPoint: { @@ -188,8 +188,8 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) // Calculate the delta temperature DeltaTemp = LoopSetPointTemperature - TargetTemp; - EnthalpySteamSatVapor = Fluid::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); - EnthalpySteamSatLiquid = Fluid::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatVapor = FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatLiquid = FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); LatentHeatSteam = EnthalpySteamSatVapor - EnthalpySteamSatLiquid; diff --git a/src/EnergyPlus/Plant/LoopSide.cc b/src/EnergyPlus/Plant/LoopSide.cc index cd3713c3c08..7d91b9c4a7f 100644 --- a/src/EnergyPlus/Plant/LoopSide.cc +++ b/src/EnergyPlus/Plant/LoopSide.cc @@ -738,7 +738,7 @@ namespace DataPlant { if (thisPlantLoop.FluidType == DataLoopNode::NodeFluidType::Water) { Real64 Cp = - Fluid::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); + FluidProperties::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); { @@ -811,7 +811,7 @@ namespace DataPlant { } else if (thisPlantLoop.FluidType == DataLoopNode::NodeFluidType::Steam) { Real64 Cp = - Fluid::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); + FluidProperties::GetSpecificHeatGlycol(state, thisPlantLoop.FluidName, WeightedInletTemp, thisPlantLoop.FluidIndex, RoutineName); { @@ -824,9 +824,9 @@ namespace DataPlant { Real64 DeltaTemp = LoopSetPointTemperature - WeightedInletTemp; Real64 EnthalpySteamSatVapor = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 1.0, this->refrigIndex, RoutineNameAlt); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 1.0, this->refrigIndex, RoutineNameAlt); Real64 EnthalpySteamSatLiquid = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 0.0, this->refrigIndex, RoutineNameAlt); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, LoopSetPointTemperature, 0.0, this->refrigIndex, RoutineNameAlt); Real64 LatentHeatSteam = EnthalpySteamSatVapor - EnthalpySteamSatLiquid; @@ -1998,7 +1998,7 @@ namespace DataPlant { Real64 const InletTemp(state.dataLoopNodes->Node(InletNode).Temp); Real64 const OutletTemp(state.dataLoopNodes->Node(OutletNode).Temp); Real64 const AverageTemp((InletTemp + OutletTemp) / 2.0); - Real64 const ComponentCp(Fluid::GetSpecificHeatGlycol(state, + Real64 const ComponentCp(FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, AverageTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 2ccb556362b..d65fc52bd15 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -383,17 +383,17 @@ void GetPlantLoopData(EnergyPlusData &state) } else if (Util::SameString(Alpha(2), "WATER")) { this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = Alpha(2); - this_loop.FluidIndex = Fluid::FindGlycol(state, Alpha(2)); + this_loop.FluidIndex = FluidProperties::GetGlycolNum(state, Alpha(2)); } else if (Util::SameString(Alpha(2), "USERDEFINEDFLUIDTYPE")) { this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = Alpha(3); // check for valid fluid name - NumFluids = Fluid::CheckFluidPropertyName(state, Alpha(3)); + NumFluids = FluidProperties::CheckFluidPropertyName(state, Alpha(3)); if (NumFluids == 0) { ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", missing fluid data for Plant loop."); ErrorsFound = true; } else { - this_loop.FluidIndex = Fluid::FindGlycol(state, Alpha(3)); + this_loop.FluidIndex = FluidProperties::GetGlycolNum(state, Alpha(3)); if (this_loop.FluidIndex == 0) { ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", invalid glycol fluid data for Plant loop."); ErrorsFound = true; @@ -407,7 +407,7 @@ void GetPlantLoopData(EnergyPlusData &state) this_loop.FluidType = DataLoopNode::NodeFluidType::Water; this_loop.FluidName = "WATER"; - this_loop.FluidIndex = Fluid::FindGlycol(state, "WATER"); + this_loop.FluidIndex = FluidProperties::GetGlycolNum(state, "WATER"); } this_loop.OperationScheme = Alpha(4); // Load the Plant Control Scheme Priority List @@ -2509,7 +2509,7 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideNum).OutletNode.MassFlowRateHistory = 0.0; if (state.dataPlnt->PlantLoop(LoopNum).FluidType != DataLoopNode::NodeFluidType::Steam) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LoopSetPointTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -2518,7 +2518,7 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) } // Use Min/Max flow rates to initialize loop if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, LoopSetPointTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -2531,9 +2531,9 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { SteamTemp = 100.0; SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); LoopMaxMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MaxVolFlowRate * SteamDensity; - StartEnthalpy = Fluid::GetSatEnthalpyRefrig( + StartEnthalpy = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, LoopSetPointTemp, 0.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); LoopMinMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate * SteamDensity; } @@ -3238,10 +3238,10 @@ void SizePlantLoop(EnergyPlusData &state, // should now have plant volume, calculate plant volume's mass for fluid type if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - FluidDensity = Fluid::GetDensityGlycol( + FluidDensity = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); if (PlantSizNum > 0 && allocated(state.dataSize->PlantSizData)) { // method only works if sizing delta T is avaiable - Real64 cp = Fluid::GetSpecificHeatGlycol(state, + Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, @@ -3251,7 +3251,7 @@ void SizePlantLoop(EnergyPlusData &state, state.dataSize->PlantSizData(PlantSizNum).DesCapacity = DesignPlantCapacity; // store it for later use in scaling } } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } @@ -3382,10 +3382,10 @@ void ResizePlantLoopLevelSizes(EnergyPlusData &state, int const LoopNum // Suppl // should now have plant volume, calculate plant volume's mass for fluid type if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { - FluidDensity = Fluid::GetDensityGlycol( + FluidDensity = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } diff --git a/src/EnergyPlus/PlantCentralGSHP.cc b/src/EnergyPlus/PlantCentralGSHP.cc index a698ab2be93..323da9bafe3 100644 --- a/src/EnergyPlus/PlantCentralGSHP.cc +++ b/src/EnergyPlus/PlantCentralGSHP.cc @@ -313,13 +313,13 @@ void WrapperSpecs::SizeWrapper(EnergyPlusData &state) // each individual chiller heater module is sized to be capable of supporting the total load on the wrapper if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpEvapVolFlowRate > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -414,13 +414,13 @@ void WrapperSpecs::SizeWrapper(EnergyPlusData &state) // each individual chiller heater module is sized to be capable of supporting the total load on the wrapper if (PltSizCondNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, RoutineName); // TODO: JM 2018-12-06 I wonder why Cp isn't calculated at the same temp as rho... - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, this->ChillerHeater(NumChillerHeater).TempRefCondInCooling, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, @@ -1685,7 +1685,7 @@ void WrapperSpecs::initialize(EnergyPlusData &state, this->GLHEVolFlowRate += this->ChillerHeater(ChillerHeaterNum).CondVolFlowRate; } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1899,17 +1899,17 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) // Calculate density ratios to adjust mass flow rates from initialized ones // Hot water temperature is known, but evaporator mass flow rates will be adjusted in the following "Do" loop - Real64 InitDensity = Fluid::GetDensityGlycol(state, + Real64 InitDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 EvapDensity = Fluid::GetDensityGlycol(state, + Real64 EvapDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CondDensity = Fluid::GetDensityGlycol(state, + Real64 CondDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2028,7 +2028,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) } // Calculate the specific heat of chilled water - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2165,7 +2165,7 @@ void WrapperSpecs::CalcChillerModel(EnergyPlusData &state) } if (CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->GLHEPlantLoc.loopNum).FluidIndex, @@ -2340,17 +2340,17 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Calculate density ratios to adjust mass flow rates from initialized ones // Hot water temperature is known, but condenser mass flow rates will be adjusted in the following "Do" loop - Real64 InitDensity = Fluid::GetDensityGlycol(state, + Real64 InitDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 EvapDensity = Fluid::GetDensityGlycol(state, + Real64 EvapDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, EvapInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 CondDensity = Fluid::GetDensityGlycol(state, + Real64 CondDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2442,7 +2442,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Mode 4 uses all data from the chilled water loop due to no heating demand if (this->SimulClgDominant || CurrentMode == 3) { CurrentMode = 3; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -2557,7 +2557,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) PartLoadRat = 0.0; } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, this->ChillerHeater(ChillerHeaterNum).EvapInletNode.Temp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, @@ -2646,7 +2646,7 @@ void WrapperSpecs::CalcChillerHeaterModel(EnergyPlusData &state) // Set load this chiller heater should meet and temperatures given QCondenser = min(HeatingLoadToMeet, QCondenser); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantChillers.cc b/src/EnergyPlus/PlantChillers.cc index 82c29986718..a51e5cbca6c 100644 --- a/src/EnergyPlus/PlantChillers.cc +++ b/src/EnergyPlus/PlantChillers.cc @@ -855,7 +855,7 @@ namespace PlantChillers { if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -869,7 +869,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; // old behavior, still want? - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -896,7 +896,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1030,12 +1030,12 @@ namespace PlantChillers { Real64 tmpNomCap = this->NomCap; if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1152,12 +1152,12 @@ namespace PlantChillers { Real64 tmpCondVolFlowRate = this->CondVolFlowRate; if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1575,7 +1575,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -1815,7 +1815,7 @@ namespace PlantChillers { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If Heat Recovery specified for this vapor compression chiller, then Qcondenser will be adjusted by this subroutine if (this->HeatRecActive) this->calcHeatRecovery(state, this->QCondenser, this->CondMassFlowRate, condInletTemp, this->QHeatRecovered); - Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, + Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -1906,7 +1906,7 @@ namespace PlantChillers { this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; - Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -1914,7 +1914,7 @@ namespace PlantChillers { Real64 CpCond; if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { - CpCond = Fluid::GetSpecificHeatGlycol(state, + CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2917,7 +2917,7 @@ namespace PlantChillers { // Initialize critical Demand Side Variables if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -2932,7 +2932,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -2958,7 +2958,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -3051,12 +3051,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3172,13 +3172,13 @@ namespace PlantChillers { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -3612,7 +3612,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -3853,7 +3853,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, + Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -4008,7 +4008,7 @@ namespace PlantChillers { this->HeatRecMdotActual = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 cp = Fluid::GetSpecificHeatGlycol(state, + Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -4902,7 +4902,7 @@ namespace PlantChillers { if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -4916,7 +4916,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = this->TempDesCondIn; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -4942,7 +4942,7 @@ namespace PlantChillers { } if (this->HeatRecActive) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -5035,12 +5035,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -5160,12 +5160,12 @@ namespace PlantChillers { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, this->TempDesCondIn, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -5617,7 +5617,7 @@ namespace PlantChillers { OperPartLoadRat = 0.0; } - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -5843,7 +5843,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 CpCond = Fluid::GetSpecificHeatGlycol(state, + Real64 CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, condInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -5922,7 +5922,7 @@ namespace PlantChillers { // This mdot is input specified mdot "Desired Flowrate", already set at node in init routine heatRecMdot = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; this->HeatRecInletTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 HeatRecCp = Fluid::GetSpecificHeatGlycol(state, + Real64 HeatRecCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidName, this->HeatRecInletTemp, state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).FluidIndex, @@ -6682,7 +6682,7 @@ namespace PlantChillers { // Initialize critical Demand Side Variables at the beginning of each environment if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -6695,7 +6695,7 @@ namespace PlantChillers { state.dataLoopNodes->Node(this->CondInletNodeNum).Temp = TempDesCondIn; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -6787,12 +6787,12 @@ namespace PlantChillers { if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -6915,12 +6915,12 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { if (PltSizCondNum > 0 && PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, 29.44, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, @@ -7247,7 +7247,7 @@ namespace PlantChillers { // condenser side outlet temperature. // local for fluid specif heat, for evaporator - Real64 const Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 const Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).FluidIndex, @@ -7437,7 +7437,7 @@ namespace PlantChillers { if (this->CondenserType == DataPlant::CondenserType::WaterCooled) { // local for fluid specif heat, for condenser - Real64 const CpCond = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpCond = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidName, CondInletTemp, state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantComponentTemperatureSources.cc b/src/EnergyPlus/PlantComponentTemperatureSources.cc index f9eaec46b5e..03089902c9f 100644 --- a/src/EnergyPlus/PlantComponentTemperatureSources.cc +++ b/src/EnergyPlus/PlantComponentTemperatureSources.cc @@ -132,7 +132,7 @@ namespace PlantComponentTemperatureSources { // Initialize critical Demand Side Variables at the beginning of each environment if (this->MyEnvironFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -154,7 +154,7 @@ namespace PlantComponentTemperatureSources { } // Calculate specific heat - Real64 cp = Fluid::GetSpecificHeatGlycol(state, + Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->BoundaryTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -364,7 +364,7 @@ namespace PlantComponentTemperatureSources { if (this->MassFlowRate > 0.0) { this->OutletTemp = this->BoundaryTemp; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->BoundaryTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantCondLoopOperation.cc b/src/EnergyPlus/PlantCondLoopOperation.cc index 2353b57dcdc..39a5f69ed1b 100644 --- a/src/EnergyPlus/PlantCondLoopOperation.cc +++ b/src/EnergyPlus/PlantCondLoopOperation.cc @@ -102,7 +102,7 @@ namespace EnergyPlus::PlantCondLoopOperation { // Using/Aliasing using namespace DataPlant; -using Fluid::GetSpecificHeatGlycol; +using FluidProperties::GetSpecificHeatGlycol; using HVAC::SmallLoad; void ManagePlantLoadDistribution(EnergyPlusData &state, @@ -3679,7 +3679,7 @@ void FindCompSPLoad(EnergyPlusData &state, // Using/Aliasing using DataLoopNode::SensedNodeFlagValue; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; // Locals // SUBROUTINE ARGUMENT DEFINITIONS: diff --git a/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc b/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc index 2bf0a4e077c..31d1dbb94b8 100644 --- a/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc +++ b/src/EnergyPlus/PlantHeatExchangerFluidToFluid.cc @@ -648,7 +648,7 @@ void HeatExchangerStruct::initialize(EnergyPlusData &state) if (state.dataGlobal->BeginEnvrnFlag && this->MyEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, @@ -660,7 +660,7 @@ void HeatExchangerStruct::initialize(EnergyPlusData &state) this->DemandSideLoop.inletNodeNum, this->DemandSideLoop.outletNodeNum); - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -807,13 +807,13 @@ void HeatExchangerStruct::size(EnergyPlusData &state) Real64 tmpDeltaTSupLoop = state.dataSize->PlantSizData(PltSizNumSupSide).DeltaT; if (tmpSupSideDesignVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -901,13 +901,13 @@ void HeatExchangerStruct::size(EnergyPlusData &state) } } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); Real64 SupSideMdot = this->SupplySideLoop.DesignVolumeFlowRate * rho; - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, @@ -996,7 +996,7 @@ void HeatExchangerStruct::control(EnergyPlusData &state, Real64 MyLoad, bool Fir state, mdotSupSide, this->SupplySideLoop.inletNodeNum, this->SupplySideLoop.outletNodeNum, this->SupplySideLoop); if (mdotSupSide > DataBranchAirLoopPlant::MassFlowTolerance) { // if supply side loop has massflow, request demand side flow - Real64 cp = Fluid::GetSpecificHeatGlycol(state, + Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, this->SupplySideLoop.InletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -1031,7 +1031,7 @@ void HeatExchangerStruct::control(EnergyPlusData &state, Real64 MyLoad, bool Fir PlantUtilities::SetComponentFlowRate( state, mdotSupSide, this->SupplySideLoop.inletNodeNum, this->SupplySideLoop.outletNodeNum, this->SupplySideLoop); if (mdotSupSide > DataBranchAirLoopPlant::MassFlowTolerance) { - Real64 cp = Fluid::GetSpecificHeatGlycol(state, + Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, this->SupplySideLoop.InletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, @@ -1503,14 +1503,14 @@ void HeatExchangerStruct::calculate(EnergyPlusData &state, Real64 const SupSideM Real64 DmdSideLoopInletTemp = state.dataLoopNodes->Node(this->DemandSideLoop.inletNodeNum).Temp; // specific heat of fluid entering from supply side loop at inlet temp - Real64 SupSideLoopInletCp = Fluid::GetSpecificHeatGlycol(state, + Real64 SupSideLoopInletCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidName, SupSideLoopInletTemp, state.dataPlnt->PlantLoop(this->SupplySideLoop.loopNum).FluidIndex, RoutineName); // specific heat of fluid entering from demand side loop at inlet temp - Real64 DmdSideLoopInletCp = Fluid::GetSpecificHeatGlycol(state, + Real64 DmdSideLoopInletCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidName, DmdSideLoopInletTemp, state.dataPlnt->PlantLoop(this->DemandSideLoop.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantLoadProfile.cc b/src/EnergyPlus/PlantLoadProfile.cc index 76b2a888990..fa976ca3efe 100644 --- a/src/EnergyPlus/PlantLoadProfile.cc +++ b/src/EnergyPlus/PlantLoadProfile.cc @@ -142,7 +142,7 @@ void PlantProfileData::simulate(EnergyPlusData &state, if (this->FluidType == PlantLoopFluidType::Water) { if (this->MassFlowRate > 0.0) { - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -155,25 +155,25 @@ void PlantProfileData::simulate(EnergyPlusData &state, this->OutletTemp = this->InletTemp - DeltaTemp; } else if (this->FluidType == PlantLoopFluidType::Steam) { if (this->MassFlowRate > 0.0 && this->Power > 0.0) { - Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 1.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 0.0, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - Real64 SatTemp = Fluid::GetSatTemperatureRefrig(state, + Real64 SatTemp = FluidProperties::GetSatTemperatureRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataEnvironment::StdPressureSeaLevel, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 CpWater = Fluid::GetSpecificHeatGlycol(state, + Real64 CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, SatTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -232,18 +232,18 @@ void PlantProfileData::InitPlantProfile(EnergyPlusData &state) state.dataLoopNodes->Node(OutletNode).Temp = 0.0; if (this->FluidType == PlantLoopFluidType::Water) { - FluidDensityInit = Fluid::GetDensityGlycol(state, + FluidDensityInit = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); } else { //(this->FluidType == PlantLoopFluidType::Steam) - Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig(state, + Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataEnvironment::StdPressureSeaLevel, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - FluidDensityInit = Fluid::GetSatDensityRefrig(state, + FluidDensityInit = FluidProperties::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, SatTempAtmPress, 1.0, @@ -271,13 +271,13 @@ void PlantProfileData::InitPlantProfile(EnergyPlusData &state) if (this->EMSOverridePower) this->Power = this->EMSPowerValue; if (this->FluidType == PlantLoopFluidType::Water) { - FluidDensityInit = Fluid::GetDensityGlycol(state, + FluidDensityInit = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); } else { //(this->FluidType == PlantLoopFluidType::Steam) - FluidDensityInit = Fluid::GetSatDensityRefrig(state, + FluidDensityInit = FluidProperties::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, 1.0, diff --git a/src/EnergyPlus/PlantLoopHeatPumpEIR.cc b/src/EnergyPlus/PlantLoopHeatPumpEIR.cc index 125b06fc88b..9eff1c9a64f 100644 --- a/src/EnergyPlus/PlantLoopHeatPumpEIR.cc +++ b/src/EnergyPlus/PlantLoopHeatPumpEIR.cc @@ -142,7 +142,7 @@ void EIRPlantLoopHeatPump::simulate( if (this->running) { if (this->sysControlType == ControlType::Setpoint) { Real64 leavingSetpoint = state.dataLoopNodes->Node(this->loadSideNodes.outlet).TempSetPoint; - Real64 CurSpecHeat = Fluid::GetSpecificHeatGlycol(state, + Real64 CurSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInletTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -488,7 +488,7 @@ void EIRPlantLoopHeatPump::calcAvailableCapacity(EnergyPlusData &state, Real64 c if (this->heatRecoveryHeatPump) { // check to see if souce side outlet temp exceeds limit and reduce PLR if necessary auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - Real64 const CpSrc = Fluid::GetSpecificHeatGlycol( + Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol( state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, "EIRPlantLoopHeatPump::doPhysics()"); Real64 const sourceMCp = this->sourceSideMassFlowRate * CpSrc; Real64 const tempSourceOutletTemp = @@ -556,7 +556,7 @@ void EIRPlantLoopHeatPump::calcLoadSideHeatTransfer(EnergyPlusData &state, Real6 { // evaluate the actual current operating load side heat transfer rate auto &thisLoadPlantLoop = state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum); - Real64 CpLoad = Fluid::GetSpecificHeatGlycol(state, + Real64 CpLoad = FluidProperties::GetSpecificHeatGlycol(state, thisLoadPlantLoop.FluidName, state.dataLoopNodes->Node(this->loadSideNodes.inlet).Temp, thisLoadPlantLoop.FluidIndex, @@ -610,7 +610,7 @@ void EIRPlantLoopHeatPump::calcSourceSideHeatTransferWSHP(EnergyPlusData &state) // calculate source side outlet conditions auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - Real64 const CpSrc = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol(state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, @@ -658,7 +658,7 @@ void EIRPlantLoopHeatPump::calcHeatRecoveryHeatTransferASHP(EnergyPlusData &stat // calculate heat recovery side outlet conditions auto &thisHeatRecoveryPlantLoop = state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum); - Real64 const CpHR = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpHR = FluidProperties::GetSpecificHeatGlycol(state, thisHeatRecoveryPlantLoop.FluidName, this->heatRecoveryInletTemp, thisHeatRecoveryPlantLoop.FluidIndex, @@ -958,7 +958,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused if (state.dataGlobal->BeginEnvrnFlag && this->envrnInit && state.dataPlnt->PlantFirstSizesOkayToFinalize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -967,7 +967,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused PlantUtilities::InitComponentNodes(state, 0.0, this->loadSideDesignMassFlowRate, this->loadSideNodes.inlet, this->loadSideNodes.outlet); if (this->waterSource) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum).FluidIndex, @@ -980,7 +980,7 @@ void EIRPlantLoopHeatPump::onInitLoopEquip(EnergyPlusData &state, [[maybe_unused this->sourceSideDesignMassFlowRate = rho * this->sourceSideDesignVolFlowRate; // heat recovery if (this->heatRecoveryAvailable) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, @@ -1044,12 +1044,12 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRHeating) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; // I guess I can assume the plant fluids are the same for HW and CW. So only the sizing type is an issue on which to use. - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, loadSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -1076,13 +1076,13 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) Real64 compCp = Cp; Real64 compDeltaT = deltaT; if (compLoopNum > 0) { - compRho = Fluid::GetDensityGlycol( + compRho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling ? Constant::HWInitConvTemp : Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - compCp = Fluid::GetSpecificHeatGlycol( + compCp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling ? Constant::HWInitConvTemp : Constant::CWInitConvTemp, @@ -1132,12 +1132,12 @@ void EIRPlantLoopHeatPump::sizeLoadSide(EnergyPlusData &state) (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; int compLoopNum = this->companionHeatPumpCoil->loadSidePlantLoc.loopNum; if (compLoopNum > 0) { - Real64 const compRho = Fluid::GetDensityGlycol(state, + Real64 const compRho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, compLoadSideInitTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeLoadSide()"); - Real64 const compCp = Fluid::GetSpecificHeatGlycol(state, + Real64 const compCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(compLoopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(compLoopNum).FluidIndex, @@ -1311,12 +1311,12 @@ void EIRPlantLoopHeatPump::sizeSrcSideWSHP(EnergyPlusData &state) Real64 sourceSideInitTemp = (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::CWInitConvTemp : Constant::HWInitConvTemp; - Real64 const rhoSrc = Fluid::GetDensityGlycol(state, + Real64 const rhoSrc = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, sourceSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeSrcSideWSHP()"); - Real64 const CpSrc = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpSrc = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidName, sourceSideInitTemp, state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum).FluidIndex, @@ -1536,12 +1536,12 @@ void EIRPlantLoopHeatPump::sizeHeatRecoveryASHP(EnergyPlusData &state) std::string_view const typeName = DataPlant::PlantEquipTypeNames[static_cast(this->EIRHPType)]; Real64 heatRecoveryInitTemp = (this->EIRHPType == DataPlant::PlantEquipmentType::HeatPumpEIRCooling) ? Constant::HWInitConvTemp : Constant::CWInitConvTemp; - Real64 const rhoHR = Fluid::GetDensityGlycol(state, + Real64 const rhoHR = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, heatRecoveryInitTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, "EIRPlantLoopHeatPump::sizeHeatRecoveryASHP()"); - Real64 const CpHR = Fluid::GetSpecificHeatGlycol(state, + Real64 const CpHR = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidName, heatRecoveryInitTemp, state.dataPlnt->PlantLoop(this->heatRecoveryPlantLoc.loopNum).FluidIndex, @@ -2504,7 +2504,7 @@ void EIRFuelFiredHeatPump::doPhysics(EnergyPlusData &state, Real64 currentLoad) } DataPlant::PlantLoopData &thisLoadPlantLoop = state.dataPlnt->PlantLoop(this->loadSidePlantLoc.loopNum); - Real64 CpLoad = Fluid::GetSpecificHeatGlycol( + Real64 CpLoad = FluidProperties::GetSpecificHeatGlycol( state, thisLoadPlantLoop.FluidName, thisInletNode.Temp, thisLoadPlantLoop.FluidIndex, "PLFFHPEIR::simulate()"); // Set the current load equal to the FFHP load @@ -2890,7 +2890,7 @@ void EIRFuelFiredHeatPump::doPhysics(EnergyPlusData &state, Real64 currentLoad) Real64 CpSrc = 0.0; if (this->waterSource) { auto &thisSourcePlantLoop = state.dataPlnt->PlantLoop(this->sourceSidePlantLoc.loopNum); - CpSrc = Fluid::GetSpecificHeatGlycol( + CpSrc = FluidProperties::GetSpecificHeatGlycol( state, thisSourcePlantLoop.FluidName, this->sourceSideInletTemp, thisSourcePlantLoop.FluidIndex, "PLFFHPEIR::simulate()"); } else if (this->airSource) { CpSrc = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat); diff --git a/src/EnergyPlus/PlantPipingSystemsManager.cc b/src/EnergyPlus/PlantPipingSystemsManager.cc index a4537988cf5..dc8deb1da92 100644 --- a/src/EnergyPlus/PlantPipingSystemsManager.cc +++ b/src/EnergyPlus/PlantPipingSystemsManager.cc @@ -2109,7 +2109,7 @@ namespace PlantPipingSystemsManager { } // Once we find ourselves on the plant loop, we can do other things - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, @@ -5689,22 +5689,22 @@ namespace PlantPipingSystemsManager { // retrieve fluid properties based on the circuit inlet temperature -- which varies during the simulation // but need to verify the value of inlet temperature during warm up, etc. - FluidCp = Fluid::GetSpecificHeatGlycol(state, + FluidCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidDensity = Fluid::GetDensityGlycol(state, + FluidDensity = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidConductivity = Fluid::GetConductivityGlycol(state, + FluidConductivity = FluidProperties::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, RoutineName); - FluidViscosity = Fluid::GetViscosityGlycol(state, + FluidViscosity = FluidProperties::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidName, thisCircuit->InletTemperature, state.dataPlnt->PlantLoop(thisCircuit->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PlantPressureSystem.cc b/src/EnergyPlus/PlantPressureSystem.cc index 8f04efbdc57..dc15cff6b4c 100644 --- a/src/EnergyPlus/PlantPressureSystem.cc +++ b/src/EnergyPlus/PlantPressureSystem.cc @@ -375,8 +375,8 @@ void BranchPressureDrop(EnergyPlusData &state, // Using/Aliasing using Curve::CurveValue; using Curve::PressureCurveValue; - using Fluid::GetDensityGlycol; - using Fluid::GetViscosityGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetViscosityGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("CalcPlantPressureSystem"); @@ -839,8 +839,8 @@ Real64 ResolveLoopFlowVsPressure(EnergyPlusData &state, // Using/Aliasing using Curve::CurveValue; - using Fluid::GetDensityGlycol; - using Fluid::GetViscosityGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetViscosityGlycol; // Return value Real64 ResolvedLoopMassFlowRate; diff --git a/src/EnergyPlus/PlantUtilities.cc b/src/EnergyPlus/PlantUtilities.cc index 493e3f2fed3..3d442924399 100644 --- a/src/EnergyPlus/PlantUtilities.cc +++ b/src/EnergyPlus/PlantUtilities.cc @@ -985,7 +985,7 @@ void UpdateChillerComponentCondenserSide(EnergyPlusData &state, // update outlet conditions if needed or possible // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("UpdateChillerComponentCondenserSide"); @@ -1079,7 +1079,7 @@ void UpdateComponentHeatRecoverySide(EnergyPlusData &state, // update outlet conditions if needed or possible // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; // SUBROUTINE PARAMETER DEFINITIONS: static constexpr std::string_view RoutineName("UpdateComponentHeatRecoverySide"); diff --git a/src/EnergyPlus/PondGroundHeatExchanger.cc b/src/EnergyPlus/PondGroundHeatExchanger.cc index f7837cfa626..2c760a70f8f 100644 --- a/src/EnergyPlus/PondGroundHeatExchanger.cc +++ b/src/EnergyPlus/PondGroundHeatExchanger.cc @@ -207,7 +207,7 @@ void GetPondGroundHeatExchanger(EnergyPlusData &state) state.dataIPShortCut->cAlphaFieldNames, state.dataIPShortCut->cNumericFieldNames); - state.dataPondGHE->PondGHE(Item).WaterIndex = Fluid::FindGlycol(state, fluidNameWater); + state.dataPondGHE->PondGHE(Item).WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // General user input data state.dataPondGHE->PondGHE(Item).Name = state.dataIPShortCut->cAlphaArgs(1); @@ -470,10 +470,10 @@ void PondGroundHeatExchangerData::CalcPondGroundHeatExchanger(EnergyPlusData &st static constexpr std::string_view RoutineName("CalcPondGroundHeatExchanger"); Real64 PondMass = this->Depth * this->Area * - Fluid::GetDensityGlycol( + FluidProperties::GetDensityGlycol( state, fluidNameWater, max(this->PondTemp, DataPrecisionGlobals::constant_zero), this->WaterIndex, RoutineName); - Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol( + Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol( state, fluidNameWater, max(this->PondTemp, DataPrecisionGlobals::constant_zero), this->WaterIndex, RoutineName); Real64 Flux = this->CalcTotalFLux(state, this->PondTemp); @@ -571,7 +571,7 @@ Real64 PondGroundHeatExchangerData::CalcTotalFLux(EnergyPlusData &state, Real64 Real64 FluxSolAbsorbed = CalcSolarFlux(state); // specific heat from fluid prop routines - Real64 SpecHeat = Fluid::GetSpecificHeatGlycol(state, + Real64 SpecHeat = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, max(this->InletTemp, 0.0), state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -713,17 +713,17 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, // evaluate properties at pipe fluid temperature for given pipe fluid - Real64 SpecificHeat = Fluid::GetSpecificHeatGlycol(state, + Real64 SpecificHeat = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Conductivity = Fluid::GetConductivityGlycol(state, + Real64 Conductivity = FluidProperties::GetConductivityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, CalledFrom); - Real64 Viscosity = Fluid::GetViscosityGlycol(state, + Real64 Viscosity = FluidProperties::GetViscosityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, InsideTemperature, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -747,10 +747,10 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, Real64 ConvCoefIn = Conductivity * NusseltNum / this->TubeInDiameter; // now find properties of pond water - always assume pond fluid is water - Real64 WaterSpecHeat = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterConductivity = Fluid::GetConductivityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterViscosity = Fluid::GetViscosityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); - Real64 WaterDensity = Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterConductivity = FluidProperties::GetConductivityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterViscosity = FluidProperties::GetViscosityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); + Real64 WaterDensity = FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 0.0), this->WaterIndex, CalledFrom); // derived properties for natural convection coefficient // expansion coef (Beta) = -1/Rho. dRho/dT @@ -758,8 +758,8 @@ Real64 PondGroundHeatExchangerData::CalcEffectiveness(EnergyPlusData &state, // It guarantees that the delta T is 10C and also avoids the problems associated with // water hitting a maximum density at around 4C. (RKS) Real64 ExpansionCoef = - -(Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) + 5.0, this->WaterIndex, CalledFrom) - - Fluid::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) - 5.0, this->WaterIndex, CalledFrom)) / + -(FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) + 5.0, this->WaterIndex, CalledFrom) - + FluidProperties::GetDensityGlycol(state, fluidNameWater, max(PondTemperature, 10.0) - 5.0, this->WaterIndex, CalledFrom)) / (10.0 * WaterDensity); Real64 ThermDiff = WaterConductivity / (WaterDensity * WaterSpecHeat); @@ -842,7 +842,7 @@ void PondGroundHeatExchangerData::UpdatePondGroundHeatExchanger(EnergyPlusData & // Calculate the water side outlet conditions and set the // appropriate conditions on the correct HVAC node. - Real64 CpFluid = Fluid::GetSpecificHeatGlycol(state, + Real64 CpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -898,12 +898,12 @@ void PondGroundHeatExchangerData::oneTimeInit(EnergyPlusData &state) if (errFlag) { ShowFatalError(state, "InitPondGroundHeatExchanger: Program terminated due to previous condition(s)."); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataPrecisionGlobals::constant_zero, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, DataPrecisionGlobals::constant_zero, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 76b8a1a0075..876a3f399cb 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -231,7 +231,6 @@ void GetPIUs(EnergyPlusData &state) using BranchNodeConnections::SetUpCompSets; using BranchNodeConnections::TestCompSet; - using Fluid::FindRefrigerant; using NodeInputManager::GetOnlySingleNode; using SteamCoils::GetCoilSteamInletNode; using WaterCoils::GetCoilWaterInletNode; @@ -323,7 +322,7 @@ void GetPIUs(EnergyPlusData &state) } case HtgCoilType::SteamAirHeating: { thisPIU.HCoil_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating; - thisPIU.HCoil_FluidIndex = FindRefrigerant(state, "Steam"); + thisPIU.HCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); if (thisPIU.HCoil_FluidIndex == 0) { ShowSevereError(state, format("{} Steam Properties for {} not found.", RoutineName, thisPIU.Name)); if (SteamMessageNeeded) { @@ -723,7 +722,7 @@ void InitPIU(EnergyPlusData &state, if (thisPIU.HotControlNode > 0) { // plant upgrade note? why no separate handling of steam coil? add it ? // local plant fluid density - Real64 const rho = Fluid::GetDensityGlycol(state, + Real64 const rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidIndex, @@ -853,8 +852,8 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) // Using/Aliasing using namespace DataSizing; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using SteamCoils::GetCoilSteamInletNode; using SteamCoils::GetCoilSteamOutletNode; using WaterCoils::GetCoilWaterInletNode; @@ -1308,12 +1307,12 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) DesCoilLoad = PsyCpAirFnW(CoilOutHumRat) * DesMassFlow * (CoilOutTemp - CoilInTemp); Real64 constexpr TempSteamIn = 100.00; Real64 const EnthSteamInDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; Real64 const SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); int DummyWaterIndex = 1; Real64 const Cp = GetSpecificHeatGlycol( state, fluidNameWater, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, DummyWaterIndex, RoutineName); @@ -1420,8 +1419,8 @@ void CalcSeriesPIU(EnergyPlusData &state, // Using/Aliasing using namespace DataZoneEnergyDemands; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using HeatingCoils::SimulateHeatingCoilComponents; using MixerComponent::SimAirMixer; using PlantUtilities::SetComponentFlowRate; diff --git a/src/EnergyPlus/Pumps.cc b/src/EnergyPlus/Pumps.cc index 9799fa8d4ef..b22f78716f8 100644 --- a/src/EnergyPlus/Pumps.cc +++ b/src/EnergyPlus/Pumps.cc @@ -217,8 +217,8 @@ void GetPumpInput(EnergyPlusData &state) using Curve::GetCurveIndex; using Curve::GetCurveMinMaxValues; using DataSizing::AutoSize; - using Fluid::GetDensityGlycol; - using Fluid::GetSatDensityRefrig; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSatDensityRefrig; using NodeInputManager::GetOnlySingleNode; using ScheduleManager::CheckScheduleValueMinMax; using ScheduleManager::GetScheduleIndex; @@ -1353,8 +1353,8 @@ void InitializePumps(EnergyPlusData &state, int const PumpNum) // This subroutine does one-time and begin-envrn inits for the pump // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSatDensityRefrig; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSatDensityRefrig; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1579,7 +1579,7 @@ void SetupPumpMinMaxFlows(EnergyPlusData &state, int const LoopNum, int const Pu // These values are also bounded by EMS overridable limit of max flow rate. // Using/Aliasing - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantPressureSystem::ResolveLoopFlowVsPressure; using PlantUtilities::BoundValueToWithinTwoValues; using ScheduleManager::GetCurrentScheduleValue; @@ -1756,8 +1756,8 @@ void CalcPumps(EnergyPlusData &state, int const PumpNum, Real64 const FlowReques // Energy Calculations, ASHRAE, 1993, pp2-10 to 2-15 // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SetComponentFlowRate; using ScheduleManager::GetCurrentScheduleValue; @@ -2018,8 +2018,8 @@ void SizePump(EnergyPlusData &state, int const PumpNum) // Obtains flow rates from the plant sizing array. // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSatDensityRefrig; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSatDensityRefrig; // SUBROUTINE PARAMETER DEFINITIONS: Real64 constexpr StartTemp(100.0); // Standard Temperature across code to calculated Steam density @@ -2325,8 +2325,8 @@ void GetRequiredMassFlowRate(EnergyPlusData &state, Real64 &PumpMaxMassFlowRateVFDRange) { // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantPressureSystem::ResolveLoopFlowVsPressure; using PlantUtilities::SetComponentFlowRate; diff --git a/src/EnergyPlus/RefrigeratedCase.cc b/src/EnergyPlus/RefrigeratedCase.cc index d2e406cb097..ec4e4873db0 100644 --- a/src/EnergyPlus/RefrigeratedCase.cc +++ b/src/EnergyPlus/RefrigeratedCase.cc @@ -4658,10 +4658,10 @@ void GetRefrigerationInput(EnergyPlusData &state) TBrineInRated = TBrineOutRated + Secondary(SecondaryNum).TRangeDifRated; Real64 TBrineAverage = (TBrineOutRated + TBrineInRated) / 2.0; Secondary(SecondaryNum).TBrineAverage = TBrineAverage; - DensityBrineRated = Fluid::GetDensityGlycol( + DensityBrineRated = FluidProperties::GetDensityGlycol( state, Secondary(SecondaryNum).FluidName, TBrineAverage, Secondary(SecondaryNum).FluidID, TrackMessage); Secondary(SecondaryNum).DensityBrineRated = DensityBrineRated; - CpBrineRated = Fluid::GetSpecificHeatGlycol( + CpBrineRated = FluidProperties::GetSpecificHeatGlycol( state, Secondary(SecondaryNum).FluidName, TBrineAverage, Secondary(SecondaryNum).FluidID, TrackMessage); Secondary(SecondaryNum).CpBrineRated = CpBrineRated; @@ -4742,19 +4742,19 @@ void GetRefrigerationInput(EnergyPlusData &state) Secondary(SecondaryNum).CircRate = DefaultCircRate; if (!lNumericBlanks(10)) Secondary(SecondaryNum).CircRate = Numbers(10); - DensityPhaseChange = Fluid::GetSatDensityRefrig(state, + DensityPhaseChange = FluidProperties::GetSatDensityRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 0.0, Secondary(SecondaryNum).FluidID, TrackMessageAlt); - DeltaHPhaseChange = Fluid::GetSatEnthalpyRefrig(state, + DeltaHPhaseChange = FluidProperties::GetSatEnthalpyRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 1.0, Secondary(SecondaryNum).FluidID, TrackMessageAlt) - - Fluid::GetSatEnthalpyRefrig(state, + FluidProperties::GetSatEnthalpyRefrig(state, Secondary(SecondaryNum).FluidName, Secondary(SecondaryNum).TCondense, 0.0, @@ -6230,15 +6230,15 @@ void GetRefrigerationInput(EnergyPlusData &state) // Determine intercooler pressure and temperature at design conditions if (System(RefrigSysNum).NumStages == 2) { - Real64 PCond = Fluid::GetSatPressureRefrig(state, + Real64 PCond = FluidProperties::GetSatPressureRefrig(state, System(RefrigSysNum).RefrigerantName, Condenser(System(RefrigSysNum).CondenserNum(1)).RatedTCondense, System(RefrigSysNum).RefIndex, RoutineName); - Real64 PEvap = Fluid::GetSatPressureRefrig( + Real64 PEvap = FluidProperties::GetSatPressureRefrig( state, System(RefrigSysNum).RefrigerantName, System(RefrigSysNum).TEvapDesign, System(RefrigSysNum).RefIndex, RoutineName); System(RefrigSysNum).PIntercooler = std::sqrt(PCond * PEvap); - System(RefrigSysNum).TIntercooler = Fluid::GetSatTemperatureRefrig( + System(RefrigSysNum).TIntercooler = FluidProperties::GetSatTemperatureRefrig( state, System(RefrigSysNum).RefrigerantName, System(RefrigSysNum).PIntercooler, System(RefrigSysNum).RefIndex, RoutineName); } // NumStages @@ -6846,7 +6846,7 @@ void GetRefrigerationInput(EnergyPlusData &state) if (Compressor(CompNum).TransFlag) { // Calculate nominal capacity of transcritical Compressor Real64 GCOutletH = - Fluid::GetSupHeatEnthalpyRefrig(state, + FluidProperties::GetSupHeatEnthalpyRefrig(state, TransSystem(TransRefrigSysNum).RefrigerantName, GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(1)).RatedOutletT, GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(1)).RatedOutletP, @@ -6948,7 +6948,7 @@ void GetRefrigerationInput(EnergyPlusData &state) } // Check receiver temperature against minimum condensing temperature (from gas cooler input) and design evaporator temperatures - TransSystem(TransRefrigSysNum).TReceiver = Fluid::GetSatTemperatureRefrig( + TransSystem(TransRefrigSysNum).TReceiver = FluidProperties::GetSatTemperatureRefrig( state, TransSystem(TransRefrigSysNum).RefrigerantName, TransSystem(TransRefrigSysNum).PReceiver, RefrigIndex, RoutineNameNoColon); if (TransSystem(TransRefrigSysNum).TReceiver > GasCooler(TransSystem(TransRefrigSysNum).GasCoolerNum(NumGasCoolers)).MinCondTemp) { ShowWarningError(state, @@ -10651,7 +10651,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidIndex, @@ -10682,7 +10682,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidIndex, @@ -10707,7 +10707,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) for (int RefCondLoop = 1; RefCondLoop <= state.dataRefrigCase->NumRefrigCondensers; ++RefCondLoop) { if (Condenser(RefCondLoop).CondenserType != DataHeatBalance::RefrigCondenserType::Water) continue; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).FluidIndex, @@ -10725,7 +10725,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) for (int RefCompRackLoop = 1; RefCompRackLoop <= state.dataRefrigCase->NumRefrigeratedRacks; ++RefCompRackLoop) { if (RefrigRack(RefCompRackLoop).CondenserType != DataHeatBalance::RefrigCondenserType::Water) continue; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidName, 20.0, state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).FluidIndex, @@ -11612,12 +11612,12 @@ void RefrigCondenserData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, @@ -11772,12 +11772,12 @@ void RefrigRackData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidName, this->InletTemp, state.dataPlnt->PlantLoop(PlantLoc.loopNum).FluidIndex, @@ -12159,9 +12159,9 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) // only calc detailed system if have load (could be zero first time through if only load is cascade condenser) thisSys.TotalSystemLoad = thisSys.TotalCoolingLoad + thisSys.SumSecondaryLoopLoad + thisSys.SumMechSCLoad + thisSys.SumCascadeLoad; if (thisSys.TotalSystemLoad > 0.0) { - thisSys.CpSatVapEvap = Fluid::GetSatSpecificHeatRefrig( + thisSys.CpSatVapEvap = FluidProperties::GetSatSpecificHeatRefrig( state, thisSys.RefrigerantName, thisSys.TEvapNeeded, 1.0, thisSys.RefIndex, RoutineName); - thisSys.HCaseOut = Fluid::GetSatEnthalpyRefrig( + thisSys.HCaseOut = FluidProperties::GetSatEnthalpyRefrig( state, thisSys.RefrigerantName, thisSys.TEvapNeeded, 1.0, thisSys.RefIndex, RoutineName) + thisSys.CpSatVapEvap * CaseSuperheat; // Establish estimates to start solution loop @@ -12187,8 +12187,8 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) // Produce first time step estimates, assume no subcoolers thisSys.HSatLiqCond = - Fluid::GetSatEnthalpyRefrig(state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); - thisSys.CpSatLiqCond = Fluid::GetSatSpecificHeatRefrig( + FluidProperties::GetSatEnthalpyRefrig(state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); + thisSys.CpSatLiqCond = FluidProperties::GetSatSpecificHeatRefrig( state, thisSys.RefrigerantName, thisSys.TCondense, 0.0, thisSys.RefIndex, RoutineName); thisSys.HCaseIn = thisSys.HSatLiqCond - thisSys.CpSatLiqCond * Condenser(thisSys.CondenserNum(1)).RatedSubcool; thisSys.RefMassFlowtoLoads = thisSys.TotalSystemLoad / (thisSys.HCaseOut - thisSys.HCaseIn); @@ -12475,24 +12475,24 @@ void SimulateDetailedTransRefrigSystems(EnergyPlusData &state) if (sys.TotalSystemLoad > 0.0) { if (sys.TransSysType == 2) { sys.CpSatVapEvapLT = - Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName); sys.HCaseOutLT = - Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName) + + FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededLT, 1.0, sys.RefIndex, RoutineName) + sys.CpSatVapEvapLT * TransCaseSuperheat; } sys.CpSatVapEvapMT = - Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName); sys.HCaseOutMT = - Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName) + + FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TEvapNeededMT, 1.0, sys.RefIndex, RoutineName) + sys.CpSatVapEvapMT * TransCaseSuperheat; // Produce first time step estimates. // Assume no subcoolers and neglect flow through bypass. - sys.TReceiver = Fluid::GetSatTemperatureRefrig(state, sys.RefrigerantName, sys.PReceiver, sys.RefIndex, RoutineName); + sys.TReceiver = FluidProperties::GetSatTemperatureRefrig(state, sys.RefrigerantName, sys.PReceiver, sys.RefIndex, RoutineName); sys.HSatLiqReceiver = - Fluid::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); sys.CpSatLiqReceiver = - Fluid::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, sys.RefrigerantName, sys.TReceiver, 0.0, sys.RefIndex, RoutineName); sys.HCaseInMT = sys.HSatLiqReceiver; sys.HCaseInLT = sys.HSatLiqReceiver; sys.RefMassFlowtoLTLoads = 0.0; @@ -13211,7 +13211,7 @@ void TransRefrigSystemData::CalcGasCooler(EnergyPlusData &state, int const SysNu if (cooler.PGasCoolerOut < 7.5e6) { // Ensure gas cooler pressure is at least 7.5 MPa for transcritical operation cooler.PGasCoolerOut = 7.5e6; } - cooler.HGasCoolerOut = Fluid::GetSupHeatEnthalpyRefrig( + cooler.HGasCoolerOut = FluidProperties::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, cooler.TGasCoolerOut, cooler.PGasCoolerOut, this->RefIndex, RoutineName); cooler.TransOpFlag = true; } else { // Gas cooler in subcritical operation @@ -13219,23 +13219,23 @@ void TransRefrigSystemData::CalcGasCooler(EnergyPlusData &state, int const SysNu if (cooler.TGasCoolerOut > 30.978) { // Gas temperature should be less than critical temperature cooler.PGasCoolerOut = 7.2e6; // Fix the pressure to be subcritical cooler.TGasCoolerOut = - Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, cooler.PGasCoolerOut, this->RefIndex, RoutineName); + FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, cooler.PGasCoolerOut, this->RefIndex, RoutineName); } else if (cooler.TGasCoolerOut > cooler.MinCondTemp) { // Allow condensing temperature to float above the minimum cooler.PGasCoolerOut = - Fluid::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); + FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); } else { // Don't allow condensing temperature to drop below minimum cooler.TGasCoolerOut = cooler.MinCondTemp; cooler.PGasCoolerOut = - Fluid::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); + FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, this->RefIndex, RoutineName); } cooler.HGasCoolerOut = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); cooler.TransOpFlag = false; } // (OutDbTemp > TransitionTemperature) if (cooler.TGasCoolerOut < 30.978) { cooler.CpGasCoolerOut = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, cooler.TGasCoolerOut, 0.0, this->RefIndex, RoutineName); } else { cooler.CpGasCoolerOut = 0.0; } @@ -13385,11 +13385,11 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) TsatforPdisch = this->TCondense + DelTDischPipes; // need (Psat of (Tcond + delT corresponding to delP disch Pipes)) TsatforPsuct = this->TEvapNeeded - DelTSuctPipes; // need (Psat of (Tevap - delT corresponding to del P suct Pipes)) HsatVaporforTevapneeded = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); this->HSatLiqCond = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); // HCaseIn is a function of the condenser rated subcooling, not the compressor rated subcooling // TCompIn needs to include case superheat as well as Temp change from lshx subcoolers // Calculate both here unless set previously by subcooler subroutine @@ -13403,23 +13403,23 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } else { // subcooler subroutine has been called to calc TCompIn and HCaseIn this->HCompIn = this->HCaseOut + this->CpSatVapEvap * (this->TCompIn - (this->TEvapNeeded + CaseSuperheat)); } // whether or not subcooler routine used - PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumCompressors; } else { // Low-stage side of two-stage system - PCond = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, this->TCondense, this->RefIndex, RoutineName); - PEvap = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, this->TEvapNeeded, this->RefIndex, RoutineName); + PCond = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, this->TCondense, this->RefIndex, RoutineName); + PEvap = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, this->TEvapNeeded, this->RefIndex, RoutineName); this->PIntercooler = std::sqrt(PCond * PEvap); this->TIntercooler = - Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, this->PIntercooler, this->RefIndex, RoutineName); + FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, this->PIntercooler, this->RefIndex, RoutineName); NeededCapacity = NeededCapacity_base; // because compressor capacity rated from txv to comp inlet TsatforPdisch = this->TIntercooler + DelTDischPipes; // need (Psat of (Tinter + delT corresponding to delP disch Pipes)) TsatforPsuct = this->TEvapNeeded - DelTSuctPipes; // need (Psat of (Tevap - delT corresponding to del P suct Pipes)) HsatVaporforTevapneeded = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeeded, 1.0, this->RefIndex, RoutineName); this->HSatLiqCond = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); // HCaseIn is a function of the condenser rated subcooling, not the compressor rated subcooling // TCompIn needs to include case superheat as well as Temp change from lshx subcoolers // Calculate both here unless set previously by subcooler subroutine @@ -13427,7 +13427,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) if (this->NumSubcoolers == 0) { // No subcooler on this system if (this->IntercoolerType == 1) { // Flash Intercooler this->HCaseIn = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); this->TLiqInActual = this->TIntercooler; } else if (this->IntercoolerType == 2) { // Shell-and-Coil Intercooler this->TLiqInActual = this->TCondense - Condenser1.RatedSubcool - @@ -13439,7 +13439,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } else { // subcooler subroutine has been called to calc TCompIn and HCaseIn this->HCompIn = this->HCaseOut + this->CpSatVapEvap * (this->TCompIn - (this->TEvapNeeded + CaseSuperheat)); } // whether or not subcooler routine used - PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumCompressors; } // NumStages } else { // Two-stage system, high-stage side @@ -13447,24 +13447,24 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) TsatforPdisch = this->TCondense + DelTDischPipes; TsatforPsuct = this->TIntercooler; HsatVaporforTevapneeded = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); - // HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, RefrigerantName, TCondense, 0.0, RefIndex, + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + // HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, RefrigerantName, TCondense, 0.0, RefIndex, // RoutineName //); ////Autodesk:Tuned These don't change for 2nd stage - // CpSatLiqCond = Fluid::GetSatSpecificHeatRefrig(RefrigerantName, TCondense, 0.0, RefIndex, + // CpSatLiqCond = FluidProperties::GetSatSpecificHeatRefrig(RefrigerantName, TCondense, 0.0, RefIndex, // RoutineName ); ////Autodesk:Tuned These don't change for 2nd stage this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * Condenser1.RatedSubcool; this->TCompIn = this->TIntercooler; // System(SysNum)%TLiqInActual = System(SysNum)%TCondense-Condenser(System(SysNum)%CondenserNum(1))%RatedSubcool this->HCompIn = HsatVaporforTevapneeded; - PSuction = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); + PSuction = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsuct, this->RefIndex, RoutineName); NumComps = this->NumHiStageCompressors; } // StageIndex // dispatch compressors to meet load, note they were listed in compressor list in dispatch order - DensityActual = Fluid::GetSupHeatDensityRefrig(state, + DensityActual = FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompIn, PSuction, @@ -13474,10 +13474,10 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) if (this->NumStages == 2) { // Autodesk:Tuned Hoisted out of CompIndex loop if (StageIndex == 1) { HCaseInRated_base = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); } else if (StageIndex == 2) { HCompInRated_base = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); } } for (int CompIndex = 1; CompIndex <= NumComps; ++CompIndex) { @@ -13542,7 +13542,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) } // Compressor SuperheatRatingType CaseEnthalpyChangeRated = HCompInRated - HCaseInRated; - DensityRated = Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRated, PSuction, this->RefIndex, RoutineName); + DensityRated = FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRated, PSuction, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling MassCorrection = DensityActual / DensityRated; @@ -13602,13 +13602,13 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) this->HCompOut = this->HCompIn + this->TotCompPower / this->RefMassFlowComps; // error found 9/19/2011, was System(SysNum)%TotCompPower*LocalTimeStep*DataGlobals::SecInHour/System(SysNum)%RefMassFlowComps } else { // High-stage compressors (only for two-stage systems) - HHiStageCompIn = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); + HHiStageCompIn = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 1.0, this->RefIndex, RoutineName); this->HCompOut = HHiStageCompIn + this->TotHiStageCompPower / this->RefMassFlowHiStageComps; } // Calculate superheat energy available for desuperheaters - HSatVapCondense = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); - CpSatVapCondense = Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); + HSatVapCondense = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); + CpSatVapCondense = FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 1.0, this->RefIndex, RoutineName); if (this->NumStages == 1) { // Single-stage systems state.dataHeatBal->HeatReclaimRefrigCondenser(CondID).AvailCapacity = this->RefMassFlowComps * (this->HCompOut - HSatVapCondense); } else { // Two-stage systems @@ -13736,10 +13736,10 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) // Determine refrigerant properties at receiver this->CpSatLiqReceiver = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TReceiver, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TReceiver, 0.0, this->RefIndex, RoutineName); // Enthalpy at the receiver bypass, J/kg - Real64 HReceiverBypass = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, 1.0, this->RefIndex, RoutineName); + Real64 HReceiverBypass = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, 1.0, this->RefIndex, RoutineName); // Determine refrigerant properties at low temperature (LT) loads (if present) // Dispatch low pressure (LP) compressors as necessary @@ -13751,12 +13751,12 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) TsatforPsucLT = this->TEvapNeededLT; TsatforPdisLT = this->TEvapNeededMT; HsatVaporforTevapneededLT = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededLT, 1.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededLT, 1.0, this->RefIndex, RoutineName); HsatLiqforTevapNeededMT = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 0.0, this->RefIndex, RoutineName); - PSuctionLT = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucLT, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 0.0, this->RefIndex, RoutineName); + PSuctionLT = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucLT, this->RefIndex, RoutineName); DensityActualLT = - Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInLP, PSuctionLT, this->RefIndex, RoutineName); + FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInLP, PSuctionLT, this->RefIndex, RoutineName); TotalEnthalpyChangeActualLT = this->HCompInLP - this->HCaseInLT; // Dispatch low pressure (LP) compressors @@ -13785,7 +13785,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } break; case CompRatingType::LiquidTemperature: { // have rated liquid temperature stored in "RatedSubcool" HCaseInRatedLT = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); } break; default: break; @@ -13798,7 +13798,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) case CompRatingType::ReturnGasTemperature: { // have rated compressor inlet temperature stored in // "CompRatingType::Superheat" TempInRatedLP = compressor.RatedSuperheat; - HCompInRatedLP = Fluid::GetSupHeatEnthalpyRefrig( + HCompInRatedLP = FluidProperties::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, compressor.RatedSuperheat, PSuctionLT, this->RefIndex, RoutineName); } break; default: @@ -13807,7 +13807,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) CaseEnthalpyChangeRatedLT = HCompInRatedLP - HCaseInRatedLT; DensityRatedLP = - Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedLP, PSuctionLT, this->RefIndex, RoutineName); + FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedLP, PSuctionLT, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling @@ -13849,10 +13849,10 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } else { // Transcritical system is operating in subcritical region TsatforPdisMT = GasCooler(this->GasCoolerNum(1)).TGasCoolerOut; } - PSuctionMT = Fluid::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucMT, this->RefIndex, RoutineName); + PSuctionMT = FluidProperties::GetSatPressureRefrig(state, this->RefrigerantName, TsatforPsucMT, this->RefIndex, RoutineName); PGCOutlet = GasCooler(this->GasCoolerNum(1)).PGasCoolerOut; HsatVaporforTevapneededMT = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 1.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TEvapNeededMT, 1.0, this->RefIndex, RoutineName); this->HCaseInMT = this->HSatLiqReceiver; // Enthalpy of refrigerant after leaving medium temperature loads and low pressure compressors @@ -13869,7 +13869,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations to find receiver quality QualityReceiver = (Xu + Xl) / 2.0; Real64 Hnew = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, QualityReceiver, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TReceiver, QualityReceiver, this->RefIndex, RoutineName); // estimated QualityReceiver is too high if (Hnew > (GasCooler(this->GasCoolerNum(1)).HGasCoolerOut + this->DelHSubcoolerDis)) { @@ -13890,11 +13890,11 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) (this->RefMassFlowtoLTLoads + this->RefMassFlowtoMTLoads + this->RefMassFlowReceiverBypass); // Iterate to find the suction temperature entering subcooler - Xl = Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); + Xl = FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); Xu = Xl + 50.0; for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations Xnew = (Xu + Xl) / 2.0; - Real64 Hnew = Fluid::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); + Real64 Hnew = FluidProperties::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); if (Hnew > this->HCompInHP) { // xnew is too high Xu = Xnew; } else { // xnew is too low @@ -13905,7 +13905,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) TSubcoolerColdIn = Xnew; // Modify receiver inlet enthalpy and HP compressor inlet enthalpy to account for subcooler - HIdeal = Fluid::GetSupHeatEnthalpyRefrig( + HIdeal = FluidProperties::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, GasCooler(this->GasCoolerNum(1)).TGasCoolerOut, PSuctionMT, this->RefIndex, RoutineName); // Only use subcooler if suction gas inlet temperature less than gas cooler outlet temperature if (TSubcoolerColdIn < GasCooler(this->GasCoolerNum(1)).TGasCoolerOut) { @@ -13918,11 +13918,11 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) this->DelHSubcoolerDis = -this->DelHSubcoolerSuc; // Iterate to find the temperature at the inlet of the high pressure (HP) compressors - Xl = Fluid::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); + Xl = FluidProperties::GetSatTemperatureRefrig(state, this->RefrigerantName, PSuctionMT, this->RefIndex, RoutineName); Xu = Xl + 50.0; for (Iter = 1; Iter <= 15; ++Iter) { // Maximum of 15 iterations Xnew = (Xu + Xl) / 2.0; - Real64 Hnew = Fluid::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); + Real64 Hnew = FluidProperties::GetSupHeatEnthalpyRefrig(state, this->RefrigerantName, Xnew, PSuctionMT, this->RefIndex, RoutineName); if (Hnew > this->HCompInHP) { // xnew is too high Xu = Xnew; } else { // xnew is too low @@ -13936,7 +13936,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) // to constitute the "load". The actual and rated conditions at the exit of the gas cooler and the inlet of the // HP compressors are used for capacity correction calculations. DensityActualMT = - Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInHP, PSuctionMT, this->RefIndex, RoutineName); + FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, this->TCompInHP, PSuctionMT, this->RefIndex, RoutineName); TotalEnthalpyChangeActualMT = this->HCompInHP - GasCooler(this->GasCoolerNum(1)).HGasCoolerOut; // Dispatch HP compressors @@ -13975,7 +13975,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) case CompRatingType::LiquidTemperature: { // have rated liquid temperature stored in "RatedSubcool" if (!GasCooler(this->GasCoolerNum(1)).TransOpFlag) { // Subcritical operation HCaseInRatedMT = - Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, compressor.RatedSubcool, 0.0, this->RefIndex, RoutineName); } else { // Transcritical operation HCaseInRatedMT = GasCooler(this->GasCoolerNum(1)).HGasCoolerOut; } // (.NOT.GasCooler(SysNum)%TransOpFlag) @@ -13990,7 +13990,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) } break; case CompRatingType::ReturnGasTemperature: { // have rated compressor inlet temperature stored in "RatedSuperheat" TempInRatedHP = compressor.RatedSuperheat; - HCompInRatedHP = Fluid::GetSupHeatEnthalpyRefrig( + HCompInRatedHP = FluidProperties::GetSupHeatEnthalpyRefrig( state, this->RefrigerantName, compressor.RatedSuperheat, PSuctionMT, this->RefIndex, RoutineName); } break; default: @@ -13999,7 +13999,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) CaseEnthalpyChangeRatedMT = HCompInRatedHP - HCaseInRatedMT; DensityRatedHP = - Fluid::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedHP, PSuctionMT, this->RefIndex, RoutineName); + FluidProperties::GetSupHeatDensityRefrig(state, this->RefrigerantName, TempInRatedHP, PSuctionMT, this->RefIndex, RoutineName); // Adjust capacity and mass flow to reflect the specific volume change due to superheating and // the increase in capacity due to extra subcooling MassCorrectionMT = DensityActualMT / DensityRatedHP; @@ -14080,25 +14080,25 @@ void RefrigSystemData::CalculateSubcoolers(EnergyPlusData &state) // HCaseIn has to be recalculated as the starting point for the subcoolers here because // of the multiple number of iterations through this subroutine and because Tcondense is evolving. if (this->NumStages == 1) { // Single-stage compression system - this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * Condenser(this->CondenserNum(1)).RatedSubcool; // Two-stage compression with flash intercooler } else if (this->NumStages == 2 && this->IntercoolerType == 1) { - this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); - this->HCaseIn = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HCaseIn = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TIntercooler, 0.0, this->RefIndex, RoutineName); // Two-stage compression with shell-and-coil intercooler } else if (this->NumStages == 2 && this->IntercoolerType == 2) { TLiqInActualLocal = this->TCondense - Condenser(this->CondenserNum(1)).RatedSubcool - this->IntercoolerEffectiveness * (this->TCondense - Condenser(this->CondenserNum(1)).RatedSubcool - this->TIntercooler); - this->HSatLiqCond = Fluid::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + this->HSatLiqCond = FluidProperties::GetSatEnthalpyRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->CpSatLiqCond = - Fluid::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); + FluidProperties::GetSatSpecificHeatRefrig(state, this->RefrigerantName, this->TCondense, 0.0, this->RefIndex, RoutineName); this->HCaseIn = this->HSatLiqCond - this->CpSatLiqCond * (this->TCondense - TLiqInActualLocal); } // NumStages and IntercoolerType diff --git a/src/EnergyPlus/ReportCoilSelection.cc b/src/EnergyPlus/ReportCoilSelection.cc index e1a237c4225..e46290b92e2 100644 --- a/src/EnergyPlus/ReportCoilSelection.cc +++ b/src/EnergyPlus/ReportCoilSelection.cc @@ -807,25 +807,25 @@ void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state) c->plantLoopName = state.dataPlnt->PlantLoop(c->waterLoopNum).Name; if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) { - c->rhoFluid = Fluid::GetDensityGlycol(state, + c->rhoFluid = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); - c->cpFluid = Fluid::GetSpecificHeatGlycol(state, + c->cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); } else { // steam loop - c->rhoFluid = Fluid::GetSatDensityRefrig(state, + c->rhoFluid = FluidProperties::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 1.0, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::doFinalProcessingOfCoilData"); - c->cpFluid = Fluid::GetSatSpecificHeatRefrig(state, + c->cpFluid = FluidProperties::GetSatSpecificHeatRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 0.0, @@ -1080,25 +1080,25 @@ void ReportCoilSelection::setCoilWaterFlowPltSizNum(EnergyPlusData &state, if (c->waterLoopNum > 0 && c->pltSizNum > 0) { if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) { - c->rhoFluid = Fluid::GetDensityGlycol(state, + c->rhoFluid = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); - c->cpFluid = Fluid::GetSpecificHeatGlycol(state, + c->cpFluid = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); } else { // steam loop - c->rhoFluid = Fluid::GetSatDensityRefrig(state, + c->rhoFluid = FluidProperties::GetSatDensityRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 1.0, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidIndex, "ReportCoilSelection::setCoilWaterFlow"); - c->cpFluid = Fluid::GetSatSpecificHeatRefrig(state, + c->cpFluid = FluidProperties::GetSatSpecificHeatRefrig(state, state.dataPlnt->PlantLoop(c->waterLoopNum).FluidName, 100.0, 0.0, diff --git a/src/EnergyPlus/RoomAirModelUserTempPattern.cc b/src/EnergyPlus/RoomAirModelUserTempPattern.cc index e97ff494632..6a0738ea74e 100644 --- a/src/EnergyPlus/RoomAirModelUserTempPattern.cc +++ b/src/EnergyPlus/RoomAirModelUserTempPattern.cc @@ -300,7 +300,7 @@ void FigureHeightPattern(EnergyPlusData &state, int const PattrnID, int const Zo // treat profile as lookup table and interpolate // Using/Aliasing - using Fluid::FindArrayIndex; + using FluidProperties::FindArrayIndex; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: diff --git a/src/EnergyPlus/SetPointManager.cc b/src/EnergyPlus/SetPointManager.cc index 43c383e07b0..80d0dfaaf40 100644 --- a/src/EnergyPlus/SetPointManager.cc +++ b/src/EnergyPlus/SetPointManager.cc @@ -3880,7 +3880,7 @@ void SPMReturnWaterTemp::calculate(EnergyPlusData &state) // fluidIndex = state.dataPlnt->PlantLoop(this->plantLoopNum).FluidIndex; // // we don't need fluid names since we have a real index, so just pass in the temperature and get properties // Real64 const avgTemp = (returnNode.Temp + supplyNode.Temp) / 2; - // Real64 const cp = Fluid::GetSpecificHeatGlycol(state, "", avgTemp, fluidIndex, "ReturnWaterChWSetPointManager::calculate"); + // Real64 const cp = FluidProperties::GetSpecificHeatGlycol(state, "", avgTemp, fluidIndex, "ReturnWaterChWSetPointManager::calculate"); // Real64 const Qdemand = mdot * cp * deltaT; // check for strange conditions diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc index 2723fbc4c3d..c65add180fb 100644 --- a/src/EnergyPlus/SimulationManager.cc +++ b/src/EnergyPlus/SimulationManager.cc @@ -2616,8 +2616,6 @@ namespace SimulationManager { // Using/Aliasing // using SQLiteProcedures::CreateSQLiteDatabase; - using Fluid::FindGlycol; - state.dataGlobal->DoingInputProcessing = false; state.dataInputProcessing->inputProcessor->preProcessorCheck( diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 5855485f416..2bcacb8ea80 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -2564,7 +2564,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI this->MassFlowDiff = 1.0e-10 * this->AirMassFlowRateMax; if (this->HWplantLoc.loopNum > 0 && this->ReheatComp_Num != HeatingCoilType::SteamAirHeating) { // protect early calls before plant is setup - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, @@ -2582,7 +2582,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI if (this->ReheatComp_Num == HeatingCoilType::SteamAirHeating) { SteamTemp = 100.0; - SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, this->FluidIndex, RoutineNameFull); + SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, this->FluidIndex, RoutineNameFull); this->MaxReheatSteamFlow = SteamDensity * this->MaxReheatSteamVolFlow; this->MinReheatSteamFlow = SteamDensity * this->MinReheatSteamVolFlow; } @@ -2784,8 +2784,8 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) // Obtains flow rates from the zone or system sizing arrays. // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using General::SafeDivide; using PlantUtilities::MyPlantSizingIndex; using SteamCoils::GetCoilSteamInletNode; @@ -3637,10 +3637,10 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS); if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) { TempSteamIn = 100.00; - EnthSteamInDry = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); - EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); Cp = GetSpecificHeatGlycol(state, fluidNameWater, diff --git a/src/EnergyPlus/SolarCollectors.cc b/src/EnergyPlus/SolarCollectors.cc index 15efc78d5b7..20efa9010b7 100644 --- a/src/EnergyPlus/SolarCollectors.cc +++ b/src/EnergyPlus/SolarCollectors.cc @@ -937,7 +937,7 @@ namespace SolarCollectors { if (state.dataGlobal->BeginEnvrnFlag && this->Init) { // Clear node initial conditions if (this->VolFlowRateMax > 0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1115,7 +1115,7 @@ namespace SolarCollectors { Real64 massFlowRate = this->MassFlowRate; // Specific heat of collector fluid (J/kg-K) - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -1405,14 +1405,14 @@ namespace SolarCollectors { Real64 massFlowRate = this->MassFlowRate; // Specific heat of collector fluid (J/kg-K) - Real64 Cpw = Fluid::GetSpecificHeatGlycol(state, + Real64 Cpw = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, RoutineName); // density of collector fluid (kg/m3) - Real64 Rhow = Fluid::GetDensityGlycol(state, + Real64 Rhow = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, inletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, @@ -2049,17 +2049,17 @@ namespace SolarCollectors { Real64 DeltaT = std::abs(TAbsorber - TWater); Real64 TReference = TAbsorber - 0.25 * (TAbsorber - TWater); // record fluid prop index for water - int WaterIndex = Fluid::FindGlycol(state, fluidNameWater); + int WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // find properties of water - always assume water - Real64 WaterSpecHeat = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 CondOfWater = Fluid::GetConductivityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 VisOfWater = Fluid::GetViscosityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); - Real64 DensOfWater = Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 WaterSpecHeat = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 CondOfWater = FluidProperties::GetConductivityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 VisOfWater = FluidProperties::GetViscosityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); + Real64 DensOfWater = FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 0.0), WaterIndex, CalledFrom); Real64 PrOfWater = VisOfWater * WaterSpecHeat / CondOfWater; // Requires a different reference temperature for volumetric expansion coefficient TReference = TWater - 0.25 * (TWater - TAbsorber); - Real64 VolExpWater = -(Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) + 5.0, WaterIndex, CalledFrom) - - Fluid::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) - 5.0, WaterIndex, CalledFrom)) / + Real64 VolExpWater = -(FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) + 5.0, WaterIndex, CalledFrom) - + FluidProperties::GetDensityGlycol(state, fluidNameWater, max(TReference, 10.0) - 5.0, WaterIndex, CalledFrom)) / (10.0 * DensOfWater); // Grashof number @@ -2116,7 +2116,7 @@ namespace SolarCollectors { PlantUtilities::SafeCopyPlantNode(state, this->InletNode, this->OutletNode); // Set outlet node variables that are possibly changed state.dataLoopNodes->Node(this->OutletNode).Temp = this->OutletTemp; - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, this->OutletTemp, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index eddcb2afa26..846600bf9ad 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -409,8 +409,8 @@ namespace StandardRatings { using namespace OutputReportPredefined; using Curve::CurveValue; using Curve::GetCurveName; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using General::SolveRoot; Real64 constexpr Acc(0.0001); // Accuracy of result diff --git a/src/EnergyPlus/SteamBaseboardRadiator.cc b/src/EnergyPlus/SteamBaseboardRadiator.cc index fbe8a7a9c94..089fd60f2db 100644 --- a/src/EnergyPlus/SteamBaseboardRadiator.cc +++ b/src/EnergyPlus/SteamBaseboardRadiator.cc @@ -267,7 +267,6 @@ namespace SteamBaseboardRadiator { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using Fluid::FindRefrigerant; using GlobalNames::VerifyUniqueBaseboardName; using NodeInputManager::GetOnlySingleNode; @@ -780,7 +779,7 @@ namespace SteamBaseboardRadiator { } if (state.dataSteamBaseboardRadiator->SteamIndex == 0 && BaseboardNum == 1) { - state.dataSteamBaseboardRadiator->SteamIndex = FindRefrigerant(state, "Steam"); + state.dataSteamBaseboardRadiator->SteamIndex = FluidProperties::GetRefrigNum(state, "Steam"); if (state.dataSteamBaseboardRadiator->SteamIndex == 0) { ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, state.dataIPShortCut->cAlphaArgs(1))); if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); @@ -909,8 +908,8 @@ namespace SteamBaseboardRadiator { // REFERENCES: // Using/Aliasing - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -1069,9 +1068,9 @@ namespace SteamBaseboardRadiator { // Using/Aliasing using namespace DataSizing; - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatSpecificHeatRefrig; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; + using FluidProperties::GetSatSpecificHeatRefrig; using HVAC::HeatingCapacitySizing; using PlantUtilities::RegisterPlantCompDesignFlow; @@ -1295,9 +1294,9 @@ namespace SteamBaseboardRadiator { // REFERENCES: // Using/Aliasing - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; - using Fluid::GetSatSpecificHeatRefrig; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; + using FluidProperties::GetSatSpecificHeatRefrig; using HVAC::SmallLoad; using ScheduleManager::GetCurrentScheduleValue; diff --git a/src/EnergyPlus/SteamCoils.cc b/src/EnergyPlus/SteamCoils.cc index f028f8ac300..1a08fa67b76 100644 --- a/src/EnergyPlus/SteamCoils.cc +++ b/src/EnergyPlus/SteamCoils.cc @@ -214,7 +214,6 @@ namespace SteamCoils { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using Fluid::FindRefrigerant; using GlobalNames::VerifyUniqueCoilName; using NodeInputManager::GetOnlySingleNode; @@ -371,7 +370,7 @@ namespace SteamCoils { TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(5), AlphArray(6), "Air Nodes"); if (state.dataSteamCoils->SteamIndex == 0 && CoilNum == 1) { - state.dataSteamCoils->SteamIndex = FindRefrigerant(state, "Steam"); + state.dataSteamCoils->SteamIndex = FluidProperties::GetRefrigNum(state, "Steam"); if (state.dataSteamCoils->SteamIndex == 0) { ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, AlphArray(1))); ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); @@ -467,8 +466,8 @@ namespace SteamCoils { // na // Using/Aliasing - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; using PlantUtilities::InitComponentNodes; // Locals @@ -663,8 +662,8 @@ namespace SteamCoils { // Using/Aliasing using namespace DataSizing; - using Fluid::GetSatDensityRefrig; - using Fluid::GetSatEnthalpyRefrig; + using FluidProperties::GetSatDensityRefrig; + using FluidProperties::GetSatEnthalpyRefrig; using PlantUtilities::RegisterPlantCompDesignFlow; // SUBROUTINE PARAMETER DEFINITIONS: @@ -827,7 +826,7 @@ namespace SteamCoils { // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'SizeSteamCoil') - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate = @@ -896,7 +895,7 @@ namespace SteamCoils { // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'SizeSteamCoil') - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate = @@ -1117,9 +1116,9 @@ namespace SteamCoils { // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. EnthSteamInDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; @@ -1128,7 +1127,7 @@ namespace SteamCoils { // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'CalcSteamAirCoil') - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Max Heat Transfer @@ -1180,7 +1179,7 @@ namespace SteamCoils { // considering saturated state. // StdBaroPress=101325 - TempWaterAtmPress = Fluid::GetSatTemperatureRefrig( + TempWaterAtmPress = FluidProperties::GetSatTemperatureRefrig( state, fluidNameSteam, state.dataEnvrn->StdBaroPress, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Point 4 at atm - loop delta subcool during return journery back to pump @@ -1188,15 +1187,15 @@ namespace SteamCoils { // Actual Steam Coil Outlet Enthalpy EnthCoilOutlet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - CpWater * SubcoolDeltaTemp; // Enthalpy at Point 4 - EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig( + EnthAtAtmPress = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, TempWaterAtmPress, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Reported value of coil outlet enthalpy at the node to match the node outlet temperature - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempLoopOutToPump, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); EnthPumpInlet = EnthAtAtmPress - CpWater * state.dataSteamCoils->SteamCoil(CoilNum).LoopSubcoolReturn; @@ -1232,16 +1231,16 @@ namespace SteamCoils { // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. EnthSteamInDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; // CpWater = GetSpecificHeatGlycol('WATER', & // TempSteamIn, & // PlantLoop(SteamCoil(CoilNum)%LoopNum)%FluidIndex, & // 'CalcSteamAirCoil') - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Max Heat Transfer @@ -1352,22 +1351,22 @@ namespace SteamCoils { // considering saturated state. // StdBaroPress=101325 - TempWaterAtmPress = Fluid::GetSatTemperatureRefrig( + TempWaterAtmPress = FluidProperties::GetSatTemperatureRefrig( state, fluidNameSteam, state.dataEnvrn->StdBaroPress, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); // Point 4 at atm - loop delta subcool during return journery back to pump TempLoopOutToPump = TempWaterAtmPress - state.dataSteamCoils->SteamCoil(CoilNum).LoopSubcoolReturn; // Actual Steam Coil Outlet Enthalpy - EnthCoilOutlet = Fluid::GetSatEnthalpyRefrig( + EnthCoilOutlet = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - CpWater * SubcoolDeltaTemp; // Enthalpy at Point 4 - EnthAtAtmPress = Fluid::GetSatEnthalpyRefrig( + EnthAtAtmPress = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, TempWaterAtmPress, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); - CpWater = Fluid::GetSatSpecificHeatRefrig( + CpWater = FluidProperties::GetSatSpecificHeatRefrig( state, fluidNameSteam, TempLoopOutToPump, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineNameSizeSteamCoil); // Reported value of coil outlet enthalpy at the node to match the node outlet temperature diff --git a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc index 9939e1b8d57..a2d01f30089 100644 --- a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc +++ b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc @@ -183,8 +183,7 @@ namespace SurfaceGroundHeatExchanger { // Using/Aliasing using BranchNodeConnections::TestCompSet; - using Fluid::CheckFluidPropertyName; - using Fluid::FindGlycol; + using FluidProperties::CheckFluidPropertyName; using NodeInputManager::GetOnlySingleNode; using namespace DataLoopNode; @@ -1078,7 +1077,7 @@ namespace SurfaceGroundHeatExchanger { // Code based loosely on code from IBLAST program (research version) // Using/Aliasing - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; // Return value Real64 CalcHXEffectTerm; @@ -1346,7 +1345,7 @@ namespace SurfaceGroundHeatExchanger { // Using/Aliasing Real64 SysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed; Real64 TimeStepSys = state.dataHVACGlobal->TimeStepSys; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::SafeCopyPlantNode; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1434,7 +1433,7 @@ namespace SurfaceGroundHeatExchanger { void SurfaceGroundHeatExchangerData::oneTimeInit_new(EnergyPlusData &state) { - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::RegisterPlantCompDesignFlow; using PlantUtilities::ScanPlantLoopsForObject; diff --git a/src/EnergyPlus/SwimmingPool.cc b/src/EnergyPlus/SwimmingPool.cc index bf4eb26a9c3..ca74f2ae0a9 100644 --- a/src/EnergyPlus/SwimmingPool.cc +++ b/src/EnergyPlus/SwimmingPool.cc @@ -510,7 +510,7 @@ void SwimmingPoolData::initialize(EnergyPlusData &state, bool const FirstHVACIte this->WaterOutletTemp = 0.0; this->WaterMassFlowRate = 0.0; this->PeopleHeatGain = 0.0; - Real64 Density = Fluid::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); + Real64 Density = FluidProperties::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); this->WaterMass = state.dataSurface->Surface(this->SurfacePtr).Area * this->AvgDepth * Density; this->WaterMassFlowRateMax = this->WaterVolFlowMax * Density; this->initSwimmingPoolPlantNodeFlow(state); @@ -917,7 +917,7 @@ void SwimmingPoolData::calculate(EnergyPlusData &state) // Get an estimate of the pool water specific heat Real64 Cp = - Fluid::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of pool water + FluidProperties::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of pool water Real64 TH22 = state.dataHeatBalSurf->SurfInsideTempHist(2)( SurfNum); // inside surface temperature at the previous time step equals the old pool water temperature @@ -1050,12 +1050,12 @@ void SwimmingPoolData::report(EnergyPlusData &state) this->PoolWaterTemp = state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum); // Next calculate the amount of heating done by the plant loop - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // specific heat of water this->HeatPower = this->WaterMassFlowRate * Cp * (this->WaterInletTemp - this->PoolWaterTemp); // Now the power consumption of miscellaneous equipment - Real64 Density = Fluid::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, + Real64 Density = FluidProperties::GetDensityGlycol(state, "WATER", this->PoolWaterTemp, this->GlycolIndex, RoutineName); // density of water if (Density > MinDensity) { this->MiscEquipPower = this->MiscPowerFactor * this->WaterMassFlowRate / Density; diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc index 05cee954296..8631437f9dc 100644 --- a/src/EnergyPlus/UnitHeater.cc +++ b/src/EnergyPlus/UnitHeater.cc @@ -658,7 +658,7 @@ namespace UnitHeater { // Using/Aliasing using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -783,7 +783,7 @@ namespace UnitHeater { } if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) { TempSteamIn = 100.00; - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_FluidIndex, RoutineName); state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotSteamFlow = SteamDensity * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow; @@ -1138,13 +1138,13 @@ namespace UnitHeater { } if (DesCoilLoad >= SmallLoad) { - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( state, state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, @@ -1269,12 +1269,12 @@ namespace UnitHeater { if (DesCoilLoad >= SmallLoad) { TempSteamIn = 100.00; EnthSteamInDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); MaxVolHotSteamFlowDes = DesCoilLoad / (SteamDensity * (LatentHeatSteam + state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * CPHW(state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp))); diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc index 04cb120f742..6e72faa07bc 100644 --- a/src/EnergyPlus/UnitVentilator.cc +++ b/src/EnergyPlus/UnitVentilator.cc @@ -1127,7 +1127,7 @@ namespace UnitVentilator { if (unitVent.HCoilType == HeatCoilType::Water) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, @@ -1142,7 +1142,7 @@ namespace UnitVentilator { if (unitVent.HCoilType == HeatCoilType::Steam) { Real64 TempSteamIn = 100.00; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, unitVent.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, unitVent.HCoil_FluidIndex, RoutineName); unitVent.MaxHotSteamFlow = SteamDensity * unitVent.MaxVolHotSteamFlow; unitVent.MinHotSteamFlow = SteamDensity * unitVent.MinVolHotSteamFlow; @@ -1152,7 +1152,7 @@ namespace UnitVentilator { } //(UnitVent(UnitVentNum)%HCoilPresent) if (unitVent.CCoilPresent) { // Only initialize these if a cooling coil is actually present - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5.0, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, @@ -1881,12 +1881,12 @@ namespace UnitVentilator { sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesHeatingLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).FluidIndex, @@ -2012,14 +2012,14 @@ namespace UnitVentilator { DesHeatingLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound); } TempSteamIn = 100.00; - EnthSteamInDry = Fluid::GetSatEnthalpyRefrig( + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitVentilators->RefrigIndex, RoutineName); - EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig( + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitVentilators->RefrigIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = Fluid::GetSatDensityRefrig( + SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitVentilators->RefrigIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, state.dataUnitVentilators->DummyWaterIndex, @@ -2170,12 +2170,12 @@ namespace UnitVentilator { sizerCoolingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesCoolingLoad = sizerCoolingCapacity.size(state, TempSize, ErrorsFound); } - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidName, 5., state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 07967395c02..cb772fa38b5 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -589,7 +589,7 @@ namespace UnitarySystems { state, CoolingCoilType, CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxCoolCoilFluidFlow > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidIndex, @@ -636,7 +636,7 @@ namespace UnitarySystems { state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxHeatCoilFluidFlow > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -652,7 +652,7 @@ namespace UnitarySystems { if (this->MaxHeatCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow *= SteamDensity; } } @@ -692,7 +692,7 @@ namespace UnitarySystems { state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->m_MaxSuppCoilFluidFlow > 0.0) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -725,7 +725,7 @@ namespace UnitarySystems { if (this->m_MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow *= SteamDensity; } @@ -764,7 +764,7 @@ namespace UnitarySystems { if ((this->m_HeatRecActive) && (!this->m_MyPlantScanFlag)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidIndex, @@ -790,7 +790,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, CoolingCoilType, this->m_CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).FluidIndex, @@ -811,7 +811,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -834,7 +834,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -851,7 +851,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -873,7 +873,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -4359,7 +4359,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); this->MaxHeatCoilFluidFlow *= SteamDensity; errFlag = false; } @@ -5379,7 +5379,7 @@ namespace UnitarySystems { if (this->m_MaxSuppCoilFluidFlow > 0.0) { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; - Real64 SteamDensity = Fluid::GetSatDensityRefrig( + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig( state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, "getUnitarySystemInputData"); this->m_MaxSuppCoilFluidFlow = this->m_MaxSuppCoilFluidFlow * SteamDensity; } @@ -9998,7 +9998,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_HeatingCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum).FluidIndex, @@ -10019,7 +10019,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -10036,7 +10036,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_SuppHeatCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidName, Constant::CWInitConvTemp, state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).FluidIndex, @@ -10056,7 +10056,7 @@ namespace UnitarySystems { int SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed Real64 TempSteamIn = 100.0; Real64 SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, SteamIndex, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity; } } @@ -15724,7 +15724,7 @@ namespace UnitarySystems { if (HeatRecMassFlowRate > 0.0) { - Real64 CpHeatRec = Fluid::GetSpecificHeatGlycol(state, + Real64 CpHeatRec = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidName, HeatRecInletTemp, state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/UserDefinedComponents.cc b/src/EnergyPlus/UserDefinedComponents.cc index 2d70b6c875f..edce549a41f 100644 --- a/src/EnergyPlus/UserDefinedComponents.cc +++ b/src/EnergyPlus/UserDefinedComponents.cc @@ -2429,13 +2429,13 @@ namespace UserDefinedComponents { // fill internal variable targets this->Loop(LoopNum).MyLoad = MyLoad; - this->Loop(LoopNum).InletRho = Fluid::GetDensityGlycol(state, + this->Loop(LoopNum).InletRho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(LoopNum).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(LoopNum).InletCp = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(LoopNum).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(LoopNum).plantLoc.loopNum).FluidIndex, @@ -2498,12 +2498,12 @@ namespace UserDefinedComponents { } if (this->PlantIsConnected) { - this->Loop.InletRho = Fluid::GetDensityGlycol(state, + this->Loop.InletRho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop.InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidIndex, RoutineName); - this->Loop.InletCp = Fluid::GetSpecificHeatGlycol(state, + this->Loop.InletCp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop.InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop.plantLoc.loopNum).FluidIndex, @@ -2581,13 +2581,13 @@ namespace UserDefinedComponents { if (this->NumPlantConnections > 0) { for (int loop = 1; loop <= this->NumPlantConnections; ++loop) { - this->Loop(loop).InletRho = Fluid::GetDensityGlycol(state, + this->Loop(loop).InletRho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(loop).InletCp = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, @@ -2663,13 +2663,13 @@ namespace UserDefinedComponents { if (this->NumPlantConnections > 0) { for (int loop = 1; loop <= this->NumPlantConnections; ++loop) { - this->Loop(loop).InletRho = Fluid::GetDensityGlycol(state, + this->Loop(loop).InletRho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, RoutineName); this->Loop(loop).InletCp = - Fluid::GetSpecificHeatGlycol(state, + FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidName, state.dataLoopNodes->Node(this->Loop(loop).InletNodeNum).Temp, state.dataPlnt->PlantLoop(this->Loop(loop).plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/VariableSpeedCoils.cc b/src/EnergyPlus/VariableSpeedCoils.cc index b35ff54ba90..7170b2096cb 100644 --- a/src/EnergyPlus/VariableSpeedCoils.cc +++ b/src/EnergyPlus/VariableSpeedCoils.cc @@ -139,7 +139,6 @@ namespace VariableSpeedCoils { // This subroutine manages variable-speed Water to Air Heat Pump component simulation. // Using/Aliasing - using Fluid::FindGlycol; using General::SolveRoot; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: @@ -3880,8 +3879,8 @@ namespace VariableSpeedCoils { // Uses the status flags to trigger initializations. // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; @@ -5283,12 +5282,12 @@ namespace VariableSpeedCoils { false); if (PltSizNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, RoutineNameAlt); - cp = Fluid::GetSpecificHeatGlycol(state, + cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, @@ -5426,7 +5425,7 @@ namespace VariableSpeedCoils { if (PltSizNum > 0) { rhoW = rho; } else { - rhoW = Fluid::GetDensityGlycol(state, + rhoW = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidName, RatedSourceTempCool, state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).FluidIndex, @@ -5874,7 +5873,7 @@ namespace VariableSpeedCoils { // Using/Aliasing using Curve::CurveValue; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyRhoAirFnPbTdbW; @@ -7236,7 +7235,7 @@ namespace VariableSpeedCoils { // Using/Aliasing using Curve::CurveValue; Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; using Psychrometrics::PsyRhoAirFnPbTdbW; @@ -7747,7 +7746,6 @@ namespace VariableSpeedCoils { // as negative. // Using/Aliasing - using Fluid::FindGlycol; // Return value Real64 CoilCapacity; // returned capacity of matched coil @@ -7808,9 +7806,6 @@ namespace VariableSpeedCoils { // incorrect coil type or name is given, ErrorsFound is returned as true and index is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int IndexNum; // returned index of matched coil @@ -7991,9 +7986,6 @@ namespace VariableSpeedCoils { // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int NodeNumber; // returned outlet node of matched coil @@ -8039,9 +8031,6 @@ namespace VariableSpeedCoils { // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int NodeNumber; // returned outlet node of matched coil @@ -8216,9 +8205,6 @@ namespace VariableSpeedCoils { // This routine was designed to "push" information from a parent object to // this WSHP coil object. - // Using/Aliasing - using Fluid::FindGlycol; - // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered GetVarSpeedCoilInput(state); diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index 893dc0220f7..455f3f92c09 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -234,7 +234,6 @@ namespace VentilatedSlab { using namespace DataLoopNode; using namespace DataSurfaceLists; - using Fluid::FindRefrigerant; using OutAirNodeManager::CheckAndAddAirNodeNumber; // SUBROUTINE PARAMETER DEFINITIONS: @@ -1024,7 +1023,7 @@ namespace VentilatedSlab { } case HeatingCoilType::Steam: { ventSlab.heatingCoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating; - ventSlab.heatingCoil_FluidIndex = FindRefrigerant(state, "Steam"); + ventSlab.heatingCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); if (ventSlab.heatingCoil_FluidIndex == 0) { ShowSevereError(state, format("{}=\"{}Steam Properties not found.", CurrentModuleObject, ventSlab.Name)); if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); @@ -1492,7 +1491,7 @@ namespace VentilatedSlab { auto &ventSlab = state.dataVentilatedSlab->VentSlab(Item); using DataZoneEquipment::CheckZoneEquipmentList; - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using ScheduleManager::GetCurrentScheduleValue; @@ -1681,7 +1680,7 @@ namespace VentilatedSlab { if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) { TempSteamIn = 100.00; - SteamDensity = Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); ventSlab.MaxHotSteamFlow = SteamDensity * ventSlab.MaxVolHotSteamFlow; ventSlab.MinHotSteamFlow = SteamDensity * ventSlab.MinVolHotSteamFlow; @@ -1789,8 +1788,8 @@ namespace VentilatedSlab { // Using/Aliasing using namespace DataSizing; - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using HVAC::CoolingCapacitySizing; using HVAC::HeatingAirflowSizing; using HVAC::HeatingCapacitySizing; @@ -2319,12 +2318,12 @@ namespace VentilatedSlab { } TempSteamIn = 100.00; EnthSteamInDry = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); EnthSteamOutWet = - Fluid::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; SteamDensity = - Fluid::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); Cp = GetSpecificHeatGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); rho = GetDensityGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); MaxVolHotSteamFlowDes = diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc index 4aae6b48349..b488f4fb3ca 100644 --- a/src/EnergyPlus/WaterCoils.cc +++ b/src/EnergyPlus/WaterCoils.cc @@ -121,8 +121,8 @@ namespace EnergyPlus::WaterCoils { using namespace DataLoopNode; -using Fluid::GetDensityGlycol; -using Fluid::GetSpecificHeatGlycol; +using FluidProperties::GetDensityGlycol; +using FluidProperties::GetSpecificHeatGlycol; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbRhPb; using Psychrometrics::PsyHFnTdbW; diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc index 18ca280aae4..730b4f5ddad 100644 --- a/src/EnergyPlus/WaterThermalTanks.cc +++ b/src/EnergyPlus/WaterThermalTanks.cc @@ -2589,7 +2589,7 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state) Tank.OnCycLossCoeff = state.dataIPShortCut->rNumericArgs(15); Tank.OnCycLossFracToZone = state.dataIPShortCut->rNumericArgs(16); - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(17) * rho; if ((state.dataIPShortCut->cAlphaArgs(14).empty()) && (state.dataIPShortCut->cAlphaArgs(15).empty())) { @@ -2828,7 +2828,7 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state) if (Tank.Volume == DataSizing::AutoSize) { Tank.VolumeWasAutoSized = true; } - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.Mass = Tank.Volume * rho; Tank.Height = state.dataIPShortCut->rNumericArgs(2); if (Tank.Height == DataSizing::AutoSize) { @@ -3132,7 +3132,7 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state) Tank.OffCycFlueLossFracToZone = state.dataIPShortCut->rNumericArgs(21); // this is temporary until we know fluid type - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(22) * rho; if ((state.dataIPShortCut->cAlphaArgs(16).empty()) && (state.dataIPShortCut->cAlphaArgs(17).empty())) { @@ -3766,7 +3766,7 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state) if (Tank.Volume == DataSizing::AutoSize) { Tank.VolumeWasAutoSized = true; } - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, Tank.FluidIndex, RoutineName); Tank.Mass = Tank.Volume * rho; Tank.Height = state.dataIPShortCut->rNumericArgs(2); if (Tank.Height == DataSizing::AutoSize) { @@ -5800,13 +5800,13 @@ void WaterThermalTankData::SetupStratifiedNodes(EnergyPlusData &state) this->Node.allocate(NumNodes); Real64 rho; if ((this->UseSidePlantLoc.loopNum > 0) && allocated(state.dataPlnt->PlantLoop)) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, RoutineName); } Real64 NodeMass = this->Volume * rho / NumNodes; @@ -6058,7 +6058,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA if (this->SetLoopIndexFlag && allocated(state.dataPlnt->PlantLoop)) { if ((this->UseInletNode > 0) && (this->HeatPumpNum == 0)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6073,7 +6073,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->UseInletNode > 0) && (this->HeatPumpNum > 0)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6088,7 +6088,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -6153,7 +6153,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA // Clear node initial conditions if (this->UseInletNode > 0 && this->UseOutletNode > 0) { state.dataLoopNodes->Node(this->UseInletNode).Temp = 0.0; - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -6170,7 +6170,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -6190,7 +6190,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA this->SourceOutletTemp = 0.0; this->SourceMassFlowRate = 0.0; this->SavedSourceOutletTemp = 0.0; - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, SizeTankForDemand); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->FluidIndex, SizeTankForDemand); this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } @@ -6835,26 +6835,26 @@ void WaterThermalTankData::CalcWaterThermalTankMixed(EnergyPlusData &state) // W Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, TankTemp_loc, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); } Real64 TankMass = rho * this->Volume; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, TankTemp_loc, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, TankTemp_loc, this->waterIndex, RoutineName); } Real64 SecInTimeStep = state.dataHVACGlobal->TimeStepSysSec; @@ -7736,13 +7736,13 @@ void WaterThermalTankData::CalcWaterThermalTankStratified(EnergyPlusData &state) // Specific Heat of water (J/kg K) const Real64 Cp = [&] { if (this->UseSidePlantLoc.loopNum > 0) { - return Fluid::GetSpecificHeatGlycol(state, + return FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, this->TankTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - return Fluid::GetSpecificHeatGlycol(state, fluidNameWater, this->TankTemp, this->waterIndex, RoutineName); + return FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, this->TankTemp, this->waterIndex, RoutineName); } }(); @@ -10720,7 +10720,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -10738,13 +10738,13 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; @@ -10783,7 +10783,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -10802,13 +10802,13 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } @@ -11015,19 +11015,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = SumPeopleAllZones * this->Sizing.RecoveryCapacityPerPerson * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * @@ -11066,19 +11066,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = SumFloorAreaAllZones * this->Sizing.RecoveryCapacityPerArea * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m2 | m3/hr/m2 | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k @@ -11111,19 +11111,19 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = this->Sizing.NumberOfUnits * this->Sizing.RecoveryCapacityPerUnit * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/ea | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k @@ -11224,19 +11224,19 @@ void WaterThermalTankData::SizeTankForSupplySide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, ((Tfinish + Tstart) / 2.0), state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); } tmpMaxCapacity = (this->Volume * rho * Cp * (Tfinish - Tstart)) / (this->Sizing.RecoveryTime * Constant::SecInHour); // m3 | kg/m3 | J/Kg/K | K | seconds @@ -11402,7 +11402,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, @@ -11422,13 +11422,13 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; } // autosizing needed. @@ -11490,7 +11490,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = Fluid::GetDensityGlycol(state, + Real64 rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, @@ -11510,13 +11510,13 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).FluidIndex, RoutineName); } else { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); } this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } // autosizing needed. @@ -11558,7 +11558,7 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) case SizingMode::PeakDraw: { // get draw rate from maximum in schedule - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, Constant::InitConvTemp, this->waterIndex, RoutineName); Real64 DrawDesignVolFlowRate = ScheduleManager::GetScheduleMaxValue(state, this->FlowRateSchedule) * this->MassFlowRateMax / rho; if (this->VolumeWasAutoSized) { @@ -11568,9 +11568,9 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) } if (this->MaxCapacityWasAutoSized) { if (this->Sizing.RecoveryTime > 0.0) { - rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); Real64 Cp = - Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = (this->Volume * rho * Cp * (Tfinish - Tstart)) / (this->Sizing.RecoveryTime * Constant::SecInHour); // m3 | kg/m3 | J/Kg/K | K | seconds @@ -11734,8 +11734,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) tmpTankVolume = this->Sizing.TankCapacityPerPerson * SumPeopleAllZones; } if (this->MaxCapacityWasAutoSized) { - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = SumPeopleAllZones * this->Sizing.RecoveryCapacityPerPerson * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/person | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } @@ -11763,8 +11763,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) } if (this->MaxCapacityWasAutoSized) { - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = SumFloorAreaAllZones * this->Sizing.RecoveryCapacityPerArea * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m2 | m3/hr/m2 | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } @@ -11783,8 +11783,8 @@ void WaterThermalTankData::SizeStandAloneWaterHeater(EnergyPlusData &state) if (this->VolumeWasAutoSized) tmpTankVolume = this->Sizing.TankCapacityPerUnit * this->Sizing.NumberOfUnits; if (this->MaxCapacityWasAutoSized) { - Real64 rho = Fluid::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 rho = FluidProperties::GetDensityGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, ((Tfinish + Tstart) / 2.0), this->waterIndex, RoutineName); tmpMaxCapacity = this->Sizing.NumberOfUnits * this->Sizing.RecoveryCapacityPerUnit * (Tfinish - Tstart) * (1.0 / Constant::SecInHour) * rho * Cp; // m3/hr/ea | delta T in K | 1 hr/ 3600 s | kg/m3 | J/Kg/k } diff --git a/src/EnergyPlus/WaterToAirHeatPump.cc b/src/EnergyPlus/WaterToAirHeatPump.cc index e070b12bdad..32c55f30d84 100644 --- a/src/EnergyPlus/WaterToAirHeatPump.cc +++ b/src/EnergyPlus/WaterToAirHeatPump.cc @@ -120,9 +120,6 @@ namespace WaterToAirHeatPump { // PURPOSE OF THIS SUBROUTINE: // This subroutine manages Water to Air Heat Pump component simulation. - // Using/Aliasing - using Fluid::FindGlycol; - // shut off after compressor cycle off [s] // cycling fan/cycling compressor @@ -131,7 +128,7 @@ namespace WaterToAirHeatPump { // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered - state.dataWaterToAirHeatPump->WaterIndex = FindGlycol(state, fluidNameWater); // Initialize the WaterIndex once + state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once GetWatertoAirHPInput(state); state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; } @@ -203,8 +200,7 @@ namespace WaterToAirHeatPump { // Using/Aliasing using namespace NodeInputManager; using BranchNodeConnections::TestCompSet; - using Fluid::CheckFluidPropertyName; - using Fluid::FindGlycol; + using FluidProperties::CheckFluidPropertyName; using GlobalNames::VerifyUniqueCoilName; using PlantUtilities::RegisterPlantCompDesignFlow; using namespace OutputReportPredefined; @@ -996,8 +992,8 @@ namespace WaterToAirHeatPump { // Uses the status flags to trigger initializations. // Using/Aliasing - using Fluid::GetDensityGlycol; - using Fluid::GetSpecificHeatGlycol; + using FluidProperties::GetDensityGlycol; + using FluidProperties::GetSpecificHeatGlycol; using PlantUtilities::InitComponentNodes; using PlantUtilities::ScanPlantLoopsForObject; using PlantUtilities::SetComponentFlowRate; @@ -1331,7 +1327,7 @@ namespace WaterToAirHeatPump { SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / - Fluid::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + FluidProperties::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); StillSimulatingFlag = true; @@ -1437,7 +1433,7 @@ namespace WaterToAirHeatPump { } // Determine Effectiveness of Source Side - CpFluid = Fluid::GetSpecificHeatGlycol( + CpFluid = FluidProperties::GetSpecificHeatGlycol( state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // IF (SourceSideFluidName=='WATER') THEN @@ -1494,9 +1490,9 @@ namespace WaterToAirHeatPump { LoadSideTemp = EvapTemp; // Determine the Load Side and Source Side Saturated Temp (evaporating and condensing pressures) - SourceSidePressure = Fluid::GetSatPressureRefrig( + SourceSidePressure = FluidProperties::GetSatPressureRefrig( state, heatPump.Refrigerant, SourceSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); - LoadSidePressure = Fluid::GetSatPressureRefrig( + LoadSidePressure = FluidProperties::GetSatPressureRefrig( state, heatPump.Refrigerant, LoadSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); if (LoadSidePressure < heatPump.LowPressCutoff && !FirstHVACIteration) { @@ -1546,18 +1542,18 @@ namespace WaterToAirHeatPump { // Determine the Load Side Outlet Enthalpy (Saturated Gas) Quality = 1.0; - LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, LoadSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); // Determine Source Side Outlet Enthalpy (Saturated Liquid) Quality = 0.0; - SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, SourceSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); // Determine Superheated Temperature of the Load Side outlet/compressor Inlet CompressInletTemp = LoadSideTemp + heatPump.SuperheatTemp; // Determine the Enthalpy of the Superheated Fluid at Load Side Outlet/Compressor Inlet - SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, + SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, CompressInletTemp, LoadSidePressure, @@ -1569,7 +1565,7 @@ namespace WaterToAirHeatPump { // Determine the saturated temp at suction pressure, shoot out into the superheated region find the enthalpy // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached if (!Converged) { - CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( + CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( state, heatPump.Refrigerant, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSuctionPr); CompSuctionTemp1 = CompSuctionSatTemp; @@ -1581,7 +1577,7 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -1591,13 +1587,13 @@ namespace WaterToAirHeatPump { heatPump.SimFlag = false; return; } - CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, + CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, state.dataWaterToAirHeatPump->CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); - CompSuctionDensity = Fluid::GetSupHeatDensityRefrig(state, + CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig(state, heatPump.Refrigerant, state.dataWaterToAirHeatPump->CompSuctionTemp, SuctionPr, @@ -1846,7 +1842,7 @@ namespace WaterToAirHeatPump { SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / - Fluid::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + FluidProperties::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // If heat pump is not operating, return if (SensDemand == 0.0 || heatPump.InletAirMassFlowRate <= 0.0 || heatPump.InletWaterMassFlowRate <= 0.0) { @@ -1906,7 +1902,7 @@ namespace WaterToAirHeatPump { // Determine Effectiveness of Source Side CpFluid = - Fluid::GetSpecificHeatGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + FluidProperties::GetSpecificHeatGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // IF (SourceSideFluidName=='WATER') THEN if (SourceSideFluidIndex == state.dataWaterToAirHeatPump->WaterIndex) { @@ -1926,9 +1922,9 @@ namespace WaterToAirHeatPump { LoadSideTemp = heatPump.InletAirDBTemp + state.dataWaterToAirHeatPump->initialQLoad * LoadSideEffect_CpAir_MassFlowRate_inv; // Determine the Load Side and Source Side Saturated Temp (evaporating and condensing pressures) - SourceSidePressure = Fluid::GetSatPressureRefrig( + SourceSidePressure = FluidProperties::GetSatPressureRefrig( state, heatPump.Refrigerant, SourceSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); - LoadSidePressure = Fluid::GetSatPressureRefrig( + LoadSidePressure = FluidProperties::GetSatPressureRefrig( state, heatPump.Refrigerant, LoadSideTemp, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); if (SourceSidePressure < heatPump.LowPressCutoff && !FirstHVACIteration) { if (!state.dataGlobal->WarmupFlag) { @@ -1991,20 +1987,20 @@ namespace WaterToAirHeatPump { // Determine the Source Side Outlet Enthalpy // Quality of the refrigerant leaving the evaporator is saturated gas Quality = 1.0; - SourceSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + SourceSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, SourceSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSourceSideTemp); // Determine Load Side Outlet Enthalpy // Quality of the refrigerant leaving the condenser is saturated liguid Quality = 0.0; - LoadSideOutletEnth = Fluid::GetSatEnthalpyRefrig( + LoadSideOutletEnth = FluidProperties::GetSatEnthalpyRefrig( state, heatPump.Refrigerant, LoadSideTemp, Quality, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameLoadSideTemp); // Determine Superheated Temperature of the Source Side outlet/compressor Inlet CompressInletTemp = SourceSideTemp + heatPump.SuperheatTemp; // Determine the Enathalpy of the Superheated Fluid at Source Side Outlet/Compressor Inlet - SuperHeatEnth = Fluid::GetSupHeatEnthalpyRefrig(state, + SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, heatPump.Refrigerant, CompressInletTemp, SourceSidePressure, @@ -2017,7 +2013,7 @@ namespace WaterToAirHeatPump { // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached if (!Converged) { - CompSuctionSatTemp = Fluid::GetSatTemperatureRefrig( + CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( state, heatPump.Refrigerant, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSuctionPr); CompSuctionTemp1 = CompSuctionSatTemp; @@ -2052,7 +2048,7 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -2061,9 +2057,9 @@ namespace WaterToAirHeatPump { heatPump.SimFlag = false; return; } - CompSuctionEnth = Fluid::GetSupHeatEnthalpyRefrig( + CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig( state, heatPump.Refrigerant, CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); - CompSuctionDensity = Fluid::GetSupHeatDensityRefrig( + CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig( state, heatPump.Refrigerant, CompSuctionTemp, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameCompSuctionTemp); // Find Refrigerant Flow Rate @@ -2442,14 +2438,14 @@ namespace WaterToAirHeatPump { Real64 CpCoolant; // Specific heat of water [J/kg-K] Real64 CondCoolant; // Conductivity of water [W/m-K] - VisWater = Fluid::GetViscosityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - DensityWater = Fluid::GetDensityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - CpWater = Fluid::GetSpecificHeatGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - CondWater = Fluid::GetConductivityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); - VisCoolant = Fluid::GetViscosityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - DensityCoolant = Fluid::GetDensityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - CpCoolant = Fluid::GetSpecificHeatGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); - CondCoolant = Fluid::GetConductivityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + VisWater = FluidProperties::GetViscosityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + DensityWater = FluidProperties::GetDensityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + CpWater = FluidProperties::GetSpecificHeatGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + CondWater = FluidProperties::GetConductivityGlycol(state, fluidNameWater, Temp, state.dataWaterToAirHeatPump->WaterIndex, CalledFrom); + VisCoolant = FluidProperties::GetViscosityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + DensityCoolant = FluidProperties::GetDensityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + CpCoolant = FluidProperties::GetSpecificHeatGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); + CondCoolant = FluidProperties::GetConductivityGlycol(state, FluidName, Temp, FluidIndex, CalledFrom); DegradF = std::pow(VisCoolant / VisWater, -0.47) * std::pow(DensityCoolant / DensityWater, 0.8) * std::pow(CpCoolant / CpWater, 0.33) * std::pow(CondCoolant / CondWater, 0.67); @@ -2475,16 +2471,13 @@ namespace WaterToAirHeatPump { // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int IndexNum; // returned index of matched coil // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered GetWatertoAirHPInput(state); - state.dataWaterToAirHeatPump->WaterIndex = FindGlycol(state, fluidNameWater); // Initialize the WaterIndex once + state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; } @@ -2516,9 +2509,6 @@ namespace WaterToAirHeatPump { // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned // as negative. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value Real64 CoilCapacity; // returned capacity of matched coil @@ -2527,7 +2517,7 @@ namespace WaterToAirHeatPump { // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered - state.dataWaterToAirHeatPump->WaterIndex = FindGlycol(state, fluidNameWater); // Initialize the WaterIndex once + state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once GetWatertoAirHPInput(state); state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; } @@ -2573,9 +2563,6 @@ namespace WaterToAirHeatPump { // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int NodeNumber; // returned outlet node of matched coil @@ -2585,7 +2572,7 @@ namespace WaterToAirHeatPump { // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered GetWatertoAirHPInput(state); - state.dataWaterToAirHeatPump->WaterIndex = FindGlycol(state, fluidNameWater); // Initialize the WaterIndex once + state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; } @@ -2621,9 +2608,6 @@ namespace WaterToAirHeatPump { // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned // as zero. - // Using/Aliasing - using Fluid::FindGlycol; - // Return value int NodeNumber; // returned outlet node of matched coil @@ -2633,7 +2617,7 @@ namespace WaterToAirHeatPump { // Obtains and Allocates WatertoAirHP related parameters from input file if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered GetWatertoAirHPInput(state); - state.dataWaterToAirHeatPump->WaterIndex = FindGlycol(state, fluidNameWater); // Initialize the WaterIndex once + state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; } diff --git a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc index 3d3a091e9ff..4da0dc01b80 100644 --- a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc +++ b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc @@ -1126,7 +1126,7 @@ namespace WaterToAirHeatPumpSimple { simpleWatertoAirHP.PartLoadRatio = 0.0; if (simpleWatertoAirHP.RatedWaterVolFlowRate != DataSizing::AutoSize) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -2865,12 +2865,12 @@ namespace WaterToAirHeatPumpSimple { false); if (PltSizNum > 0) { - rho = Fluid::GetDensityGlycol(state, + rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, RoutineNameAlt); - Cp = Fluid::GetSpecificHeatGlycol(state, + Cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataSize->PlantSizData(PltSizNum).ExitTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -3097,7 +3097,7 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = Fluid::GetSpecificHeatGlycol(state, + CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, @@ -3399,7 +3399,7 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = Fluid::GetSpecificHeatGlycol(state, + CpWater = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidName, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).FluidIndex, diff --git a/src/EnergyPlus/WaterUse.cc b/src/EnergyPlus/WaterUse.cc index 46d87616c28..9d3a86681f6 100644 --- a/src/EnergyPlus/WaterUse.cc +++ b/src/EnergyPlus/WaterUse.cc @@ -1702,7 +1702,7 @@ namespace WaterUse { if (state.dataWaterUse->calcRhoH2O) { int DummyValue = 1; - state.dataWaterUse->rhoH2OStd = Fluid::GetDensityGlycol(state, "WATER", Constant::InitConvTemp, DummyValue, RoutineName); + state.dataWaterUse->rhoH2OStd = FluidProperties::GetDensityGlycol(state, "WATER", Constant::InitConvTemp, DummyValue, RoutineName); state.dataWaterUse->calcRhoH2O = false; } return state.dataWaterUse->rhoH2OStd; diff --git a/src/EnergyPlus/api/EnergyPlusPgm.cc b/src/EnergyPlus/api/EnergyPlusPgm.cc index 6fc0c2ef5d2..a86e8c1a94e 100644 --- a/src/EnergyPlus/api/EnergyPlusPgm.cc +++ b/src/EnergyPlus/api/EnergyPlusPgm.cc @@ -360,7 +360,7 @@ int wrapUpEnergyPlus(EnergyPlus::EnergyPlusData &state) Psychrometrics::ShowPsychrometricSummary(state, state.files.audit); state.dataInputProcessing->inputProcessor->reportOrphanRecordObjects(state); - Fluid::ReportOrphanFluids(state); + FluidProperties::ReportOrphanFluids(state); ScheduleManager::ReportOrphanSchedules(state); if (state.dataSQLiteProcedures->sqlite) { state.dataSQLiteProcedures->sqlite.reset(); diff --git a/src/EnergyPlus/api/func.cc b/src/EnergyPlus/api/func.cc index 4136e0675e8..c17d244fb16 100644 --- a/src/EnergyPlus/api/func.cc +++ b/src/EnergyPlus/api/func.cc @@ -62,7 +62,7 @@ void initializeFunctionalAPI(EnergyPlusState state) thisState->dataInputProcessing->inputProcessor = EnergyPlus::InputProcessor::factory(); } EnergyPlus::Psychrometrics::InitializePsychRoutines(*thisState); - EnergyPlus::Fluid::InitializeGlycRoutines(); + EnergyPlus::FluidProperties::InitializeGlycRoutines(); } const char *apiVersionFromEPlus(EnergyPlusState) @@ -89,68 +89,68 @@ void registerErrorCallback(EnergyPlusState state, void (*f)(int, const char *)) Glycol glycolNew(EnergyPlusState state, const char *glycolName) { auto *thisState = reinterpret_cast(state); - auto *glycol = new EnergyPlus::Fluid::GlycolAPI(*thisState, glycolName); + auto *glycol = new EnergyPlus::FluidProperties::GlycolAPI(*thisState, glycolName); return reinterpret_cast(glycol); } void glycolDelete(EnergyPlusState, Glycol glycol) { - delete reinterpret_cast(glycol); + delete reinterpret_cast(glycol); } Real64 glycolSpecificHeat(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->specificHeat(*thisState, temperature); + return reinterpret_cast(glycol)->specificHeat(*thisState, temperature); } Real64 glycolDensity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->density(*thisState, temperature); + return reinterpret_cast(glycol)->density(*thisState, temperature); } Real64 glycolConductivity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->conductivity(*thisState, temperature); + return reinterpret_cast(glycol)->conductivity(*thisState, temperature); } Real64 glycolViscosity(EnergyPlusState state, Glycol glycol, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(glycol)->viscosity(*thisState, temperature); + return reinterpret_cast(glycol)->viscosity(*thisState, temperature); } Refrigerant refrigerantNew(EnergyPlusState state, const char *refrigerantName) { auto *thisState = reinterpret_cast(state); - auto *refrigerant = new EnergyPlus::Fluid::RefrigerantAPI(*thisState, refrigerantName); + auto *refrigerant = new EnergyPlus::FluidProperties::RefrigerantAPI(*thisState, refrigerantName); return reinterpret_cast(refrigerant); } void refrigerantDelete(EnergyPlusState, Refrigerant refrigerant) { - delete reinterpret_cast(refrigerant); + delete reinterpret_cast(refrigerant); } Real64 refrigerantSaturationPressure(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturationPressure(*thisState, temperature); + return reinterpret_cast(refrigerant)->saturationPressure(*thisState, temperature); } Real64 refrigerantSaturationTemperature(EnergyPlusState state, Refrigerant refrigerant, Real64 pressure) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturationTemperature(*thisState, pressure); + return reinterpret_cast(refrigerant)->saturationTemperature(*thisState, pressure); } Real64 refrigerantSaturatedEnthalpy(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedEnthalpy(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedEnthalpy(*thisState, temperature, quality); } Real64 refrigerantSaturatedDensity(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedDensity(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedDensity(*thisState, temperature, quality); } Real64 refrigerantSaturatedSpecificHeat(EnergyPlusState state, Refrigerant refrigerant, Real64 temperature, Real64 quality) { auto *thisState = reinterpret_cast(state); - return reinterpret_cast(refrigerant)->saturatedSpecificHeat(*thisState, temperature, quality); + return reinterpret_cast(refrigerant)->saturatedSpecificHeat(*thisState, temperature, quality); } // Real64 refrigerantSuperHeatedEnthalpy(EnergyPlusState, Refrigerant refrigerant, Real64 temperature, Real64 pressure) { // return reinterpret_cast(refrigerant)->superHeatedEnthalpy(temperature, pressure); diff --git a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc index f7ae5b15711..19baffc169c 100644 --- a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc +++ b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc @@ -137,12 +137,12 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) state->dataPlnt->PlantFirstSizesOkayToFinalize = true; // calculate nominal capacity at 60.0 C hot water temperature - Real64 rho = Fluid::GetDensityGlycol(*state, + Real64 rho = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidIndex, "Boiler_HotWaterAutoSizeTempTest"); - Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataBoilers->Boiler(1).plantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc b/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc index e32037d8699..7bd0003246a 100644 --- a/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc +++ b/tst/EnergyPlus/unit/ChillerAbsorption.unit.cc @@ -2022,13 +2022,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) state->dataPlnt->PlantFinalSizesOkayToReport = true; // Calculate expected values - Real64 rho_cw = Fluid::GetDensityGlycol(*state, + Real64 rho_cw = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(chwLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(chwLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 Cp_evap = Fluid::GetSpecificHeatGlycol(*state, + Real64 Cp_evap = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(chwLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(chwLoopNum).FluidIndex, @@ -2042,13 +2042,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) Real64 const SteamInputRatNom = thisChiller.SteamLoadCoef[0] + thisChiller.SteamLoadCoef[1] + thisChiller.SteamLoadCoef[2]; EXPECT_DOUBLE_EQ(1.0, SteamInputRatNom); - Real64 rho_cond = Fluid::GetDensityGlycol(*state, + Real64 rho_cond = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(cndLoopNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(cndLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 Cp_cond = Fluid::GetSpecificHeatGlycol(*state, + Real64 Cp_cond = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(cndLoopNum).FluidName, thisChiller.TempDesCondIn, state->dataPlnt->PlantLoop(cndLoopNum).FluidIndex, @@ -2058,13 +2058,13 @@ TEST_F(EnergyPlusFixture, ChillerAbsorption_Autosize) expectedNomCap * (1.0 + SteamInputRatNom + nomCapToPumpRatio) / (rho_cond * Cp_cond * state->dataSize->PlantSizData(cndLoopNum).DeltaT); Real64 const SteamDeltaT = state->dataSize->PlantSizData(genLoopNum).DeltaT; - Real64 const Cp_gen = Fluid::GetSpecificHeatGlycol(*state, + Real64 const Cp_gen = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(genLoopNum).FluidName, state->dataSize->PlantSizData(genLoopNum).ExitTemp, state->dataPlnt->PlantLoop(genLoopNum).FluidIndex, "ChillerAbsorption_Autosize_TEST"); - Real64 const rho_gen = Fluid::GetDensityGlycol(*state, + Real64 const rho_gen = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(genLoopNum).FluidName, (state->dataSize->PlantSizData(genLoopNum).ExitTemp - SteamDeltaT), state->dataPlnt->PlantLoop(genLoopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc index d06b22313a7..1aaeb633ec5 100644 --- a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc +++ b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc @@ -685,7 +685,7 @@ TEST_F(EnergyPlusFixture, ExhAbsorption_calcHeater_Fix_Test) bool const runflaginput = true; thisChillerHeater.calcHeater(*state, loadinput, runflaginput); - const Real64 CpHW = Fluid::GetSpecificHeatGlycol(*state, hwPlantLoop.FluidName, hwReturnTemp, hwPlantLoop.FluidIndex, "UnitTest"); + const Real64 CpHW = FluidProperties::GetSpecificHeatGlycol(*state, hwPlantLoop.FluidName, hwReturnTemp, hwPlantLoop.FluidIndex, "UnitTest"); EXPECT_EQ(4185.0, CpHW); const Real64 expectedHeatingLoad = (hwSupplySetpoint - hwReturnTemp) * hwMassFlow * CpHW; diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc index 5e229225aaa..c46bbb9d30f 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc @@ -118,7 +118,7 @@ void EnergyPlusFixture::SetUp() state->dataUtilityRoutines->outputErrorHeader = false; Psychrometrics::InitializePsychRoutines(*state); - Fluid::InitializeGlycRoutines(); + FluidProperties::InitializeGlycRoutines(); createCoilSelectionReportObj(*state); } @@ -349,8 +349,8 @@ bool EnergyPlusFixture::process_idf(std::string_view const idf_snippet, bool use inputProcessor->initializeMaps(); SimulationManager::PostIPProcessing(*state); - Fluid::GetFluidPropertiesData(*state); - state->dataFluid->GetInput = false; + FluidProperties::GetFluidPropertiesData(*state); + state->dataFluidProperties->GetInput = false; if (state->dataSQLiteProcedures->sqlite) { bool writeOutputToSQLite = false; diff --git a/tst/EnergyPlus/unit/FluidProperties.unit.cc b/tst/EnergyPlus/unit/FluidProperties.unit.cc index d6539ee8ed8..631475993fd 100644 --- a/tst/EnergyPlus/unit/FluidProperties.unit.cc +++ b/tst/EnergyPlus/unit/FluidProperties.unit.cc @@ -75,17 +75,17 @@ TEST_F(EnergyPlusFixture, FluidProperties_GetDensityGlycol) int FluidIndex = 0; - EXPECT_NEAR(1037.89, Fluid::GetDensityGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1037.89, Fluid::GetDensityGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1034.46, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1030.51, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1026.06, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1021.09, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1015.62, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(1003.13, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(988.60, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(972.03, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(953.41, Fluid::GetDensityGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1037.89, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1037.89, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1034.46, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1030.51, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1026.06, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1021.09, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1015.62, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(1003.13, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(988.60, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(972.03, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(953.41, FluidProperties::GetDensityGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); } TEST_F(EnergyPlusFixture, FluidProperties_GetSpecificHeatGlycol) @@ -103,17 +103,17 @@ TEST_F(EnergyPlusFixture, FluidProperties_GetSpecificHeatGlycol) int FluidIndex = 0; - EXPECT_NEAR(3779, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3779, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3807, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3834, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3862, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3889, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3917, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(3972, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4027, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4082, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); - EXPECT_NEAR(4137, Fluid::GetSpecificHeatGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3779, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", -35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3779, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", -15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3807, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 5.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3834, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 15.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3862, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 25.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3889, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 35.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3917, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 45.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(3972, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 65.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4027, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 85.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4082, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 105.0, FluidIndex, "UnitTest"), 0.01); + EXPECT_NEAR(4137, FluidProperties::GetSpecificHeatGlycol(*state, "GLHXFLUID", 125.0, FluidIndex, "UnitTest"), 0.01); } TEST_F(EnergyPlusFixture, FluidProperties_InterpValuesForGlycolConc) @@ -141,7 +141,7 @@ TEST_F(EnergyPlusFixture, FluidProperties_InterpValuesForGlycolConc) Result.allocate(NumTemp); // Test interpolation for the single-concentration scenario - Fluid::InterpValuesForGlycolConc(*state, + FluidProperties::InterpValuesForGlycolConc(*state, NumCon, // number of concentrations (dimension of raw data) NumTemp, // number of temperatures (dimension of raw data) ConData, // concentrations for raw data diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index 8b73ce09b9c..525ee7c2e2e 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -2354,7 +2354,7 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) // Read in IDF ProcessScheduleInput(*state); // read schedules Curve::GetCurveInput(*state); // read curves - Fluid::GetFluidPropertiesData(*state); // read refrigerant properties + FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; @@ -2395,7 +2395,7 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) state->dataEnvrn->OutDryBulbTemp = 10.35; // Run - Temperature = Fluid::GetSupHeatTempRefrig(*state, Refrigerant, Pressure, Enthalpy, TempLow, TempUp, RefrigIndex, CalledFrom); + Temperature = FluidProperties::GetSupHeatTempRefrig(*state, Refrigerant, Pressure, Enthalpy, TempLow, TempUp, RefrigIndex, CalledFrom); // Test EXPECT_NEAR(Temperature, 44.5, 0.5); @@ -5859,12 +5859,12 @@ TEST_F(EnergyPlusFixture, VRFTest_SysCurve_WaterCooled) EXPECT_TRUE(state->dataHVACVarRefFlow->VRF(VRFCond).VRFCondPLR > 0.0); EXPECT_NEAR(SysOutputProvided, state->dataZoneEnergyDemand->ZoneSysEnergyDemand(CurZoneNum).RemainingOutputReqToCoolSP, 1.0); - rho = Fluid::GetDensityGlycol(*state, + rho = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, state->dataSize->PlantSizData(1).ExitTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, RoutineName); - Cp = Fluid::GetSpecificHeatGlycol(*state, + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, state->dataSize->PlantSizData(1).ExitTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, @@ -5874,7 +5874,7 @@ TEST_F(EnergyPlusFixture, VRFTest_SysCurve_WaterCooled) EXPECT_DOUBLE_EQ(CondVolFlowRate, state->dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate); - rho = Fluid::GetDensityGlycol(*state, + rho = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, Constant::InitConvTemp, state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, @@ -22715,7 +22715,7 @@ TEST_F(EnergyPlusFixture, VRF_MixedTypes) // Read in IDF ProcessScheduleInput(*state); // read schedules Curve::GetCurveInput(*state); // read curves - Fluid::GetFluidPropertiesData(*state); // read refrigerant properties + FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; diff --git a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc index abf6b69f0a3..ff5fce64ea2 100644 --- a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc +++ b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc @@ -1200,24 +1200,24 @@ TEST_F(LowTempRadiantSystemTest, AutosizeLowTempRadiantVariableFlowTest) CoolingCapacity = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad * state->dataLowTempRadSys->HydrRadSys(RadSysNum).ScaledCoolingCapacity; // hot water flow rate sizing calculation - Density = Fluid::GetDensityGlycol(*state, + Density = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = Fluid::GetSpecificHeatGlycol(*state, + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); HotWaterFlowRate = HeatingCapacity / (state->dataSize->PlantSizData(1).DeltaT * Cp * Density); // chilled water flow rate sizing calculation - Density = Fluid::GetDensityGlycol(*state, + Density = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = Fluid::GetSpecificHeatGlycol(*state, + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, @@ -2630,12 +2630,12 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad = 1000.0; // hot water volume flow rate sizing calculation - Density = Fluid::GetDensityGlycol(*state, + Density = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = Fluid::GetSpecificHeatGlycol(*state, + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, @@ -2655,12 +2655,12 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax = AutoSize; // chilled water volume flow rate sizing calculation - Density = Fluid::GetDensityGlycol(*state, + Density = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = Fluid::GetSpecificHeatGlycol(*state, + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, 5.05, state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc index 8ba54110eea..95c18b51bd1 100644 --- a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc +++ b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc @@ -687,10 +687,10 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) Real64 DesWaterCoolingCoilLoad = DesAirMassFlow * (EnthalpyAirIn - EnthalpyAirOut) + FanCoolLoad; Real64 CoilDesWaterDeltaT = state->dataSize->PlantSizData(1).DeltaT; - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); Real64 rho = - Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); + FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); Real64 DesCoolingCoilWaterVolFlowRate = DesWaterCoolingCoilLoad / (CoilDesWaterDeltaT * Cp * rho); // check water coil water flow rate calc EXPECT_EQ(DesWaterCoolingCoilLoad, state->dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate); @@ -993,11 +993,11 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_SteamHeatingCoilAutoSizeTest) Real64 DesSteamCoilLoad = DesAirMassFlow * CpAirAvg * (DesCoilOutTemp - DesCoilInTemp); // do steam flow rate sizing calculation - Real64 EnthSteamIn = Fluid::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 EnthSteamOut = Fluid::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 SteamDensity = Fluid::GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamIn = FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamOut = FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); Real64 CpOfCondensate = - Fluid::GetSatSpecificHeatRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + FluidProperties::GetSatSpecificHeatRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); Real64 LatentHeatChange = EnthSteamIn - EnthSteamOut; Real64 DesMaxSteamVolFlowRate = DesSteamCoilLoad / (SteamDensity * (LatentHeatChange + state->dataSteamCoils->SteamCoil(1).DegOfSubcooling * CpOfCondensate)); diff --git a/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc b/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc index f96cb4c1ffe..8eda2e0503b 100644 --- a/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc +++ b/tst/EnergyPlus/unit/OutsideEnergySources.unit.cc @@ -139,7 +139,7 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictHeatingWater.BeginEnvrnInitFlag = true; thisDistrictHeatingWater.simulate(*state, locHotWater, firstHVAC, MyLoad, RunFlag); - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( *state, thisHotWaterLoop.FluidName, thisDistrictHeatingWater.InletTemp, thisHotWaterLoop.FluidIndex, RoutineName); Real64 calOutletTemp = (MyLoad + thisHotWaterLoop.MaxMassFlowRate * Cp * thisDistrictHeatingWater.InletTemp) / (thisHotWaterLoop.MaxMassFlowRate * Cp); @@ -173,7 +173,7 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictCooling.BeginEnvrnInitFlag = true; thisDistrictCooling.simulate(*state, locChilledWater, firstHVAC, MyLoad, RunFlag); - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, thisChilledWaterLoop.FluidName, thisDistrictCooling.InletTemp, thisChilledWaterLoop.FluidIndex, RoutineName); calOutletTemp = (MyLoad + thisChilledWaterLoop.MaxMassFlowRate * Cp * thisDistrictCooling.InletTemp) / (thisChilledWaterLoop.MaxMassFlowRate * Cp); @@ -204,14 +204,14 @@ TEST_F(EnergyPlusFixture, DistrictCoolingandHeating) thisDistrictHeatingSteam.BeginEnvrnInitFlag = true; thisDistrictHeatingSteam.simulate(*state, locSteam, firstHVAC, MyLoad, RunFlag); - Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig( + Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig( *state, thisSteamLoop.FluidName, DataEnvironment::StdPressureSeaLevel, thisSteamLoop.FluidIndex, RoutineName); - Real64 CpCondensate = Fluid::GetSpecificHeatGlycol( + Real64 CpCondensate = FluidProperties::GetSpecificHeatGlycol( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, thisSteamLoop.FluidIndex, RoutineName); Real64 deltaTsensible = SatTempAtmPress - thisDistrictHeatingSteam.InletTemp; - Real64 EnthSteamInDry = Fluid::GetSatEnthalpyRefrig( + Real64 EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, 1.0, thisSteamLoop.FluidIndex, RoutineName); - Real64 EnthSteamOutWet = Fluid::GetSatEnthalpyRefrig( + Real64 EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( *state, thisSteamLoop.FluidName, thisDistrictHeatingSteam.InletTemp, 0.0, thisSteamLoop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; Real64 calOutletMdot = MyLoad / (LatentHeatSteam + (CpCondensate * deltaTsensible)); diff --git a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc index 454e54ad473..913657fa1d0 100644 --- a/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc +++ b/tst/EnergyPlus/unit/PlantCentralGSHP.unit.cc @@ -137,25 +137,25 @@ TEST_F(EnergyPlusFixture, ChillerHeater_Autosize) state->dataPlantCentralGSHP->Wrapper(1).GLHEPlantLoc.loopNum = PltSizCondNum; // Calculate expected values - Real64 rho_evap = Fluid::GetDensityGlycol(*state, + Real64 rho_evap = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(PltSizNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 Cp_evap = Fluid::GetSpecificHeatGlycol(*state, + Real64 Cp_evap = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(PltSizNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 rho_cond = Fluid::GetDensityGlycol(*state, + Real64 rho_cond = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(PltSizCondNum).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(PltSizCondNum).FluidIndex, "ChillerHeater_Autosize_TEST"); - Real64 Cp_cond = Fluid::GetSpecificHeatGlycol(*state, + Real64 Cp_cond = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(PltSizCondNum).FluidName, state->dataPlantCentralGSHP->Wrapper(1).ChillerHeater(1).TempRefCondInCooling, state->dataPlnt->PlantLoop(PltSizCondNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc index 7996d5a5179..67142450ce6 100644 --- a/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc +++ b/tst/EnergyPlus/unit/PlantLoadProfile.unit.cc @@ -178,8 +178,8 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Waterloop) std::string_view RoutineName("PlantLoadProfileTests"); thisLoadProfileWaterLoop.simulate(*state, locWater, firstHVAC, curLoad, runFlag); - Real64 rhoWater = Fluid::GetDensityGlycol(*state, thisWaterLoop.FluidName, 60, thisWaterLoop.FluidIndex, RoutineName); - Real64 Cp = Fluid::GetSpecificHeatGlycol( + Real64 rhoWater = FluidProperties::GetDensityGlycol(*state, thisWaterLoop.FluidName, 60, thisWaterLoop.FluidIndex, RoutineName); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol( *state, thisWaterLoop.FluidName, thisLoadProfileWaterLoop.InletTemp, thisWaterLoop.FluidIndex, RoutineName); Real64 deltaTemp = curLoad / (rhoWater * thisLoadProfileWaterLoop.VolFlowRate * Cp); Real64 calOutletTemp = thisLoadProfileWaterLoop.InletTemp - deltaTemp; @@ -209,7 +209,7 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Steamloop) std::string_view RoutineName("PlantLoadProfileTests"); - Real64 SatTempAtmPress = Fluid::GetSatTemperatureRefrig( + Real64 SatTempAtmPress = FluidProperties::GetSatTemperatureRefrig( *state, state->dataPlnt->PlantLoop(1).FluidName, DataEnvironment::StdPressureSeaLevel, state->dataPlnt->PlantLoop(1).FluidIndex, RoutineName); state->dataLoopNodes->Node(1).Temp = SatTempAtmPress; @@ -252,12 +252,12 @@ TEST_F(EnergyPlusFixture, LoadProfile_initandsimulate_Steamloop) thisLoadProfileSteamLoop.simulate(*state, locSteam, firstHVAC, curLoad, runFlag); Real64 EnthSteamIn = - Fluid::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 1.0, thisSteamLoop.FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 1.0, thisSteamLoop.FluidIndex, RoutineName); Real64 EnthSteamOut = - Fluid::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 0.0, thisSteamLoop.FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(*state, thisSteamLoop.FluidName, SatTempAtmPress, 0.0, thisSteamLoop.FluidIndex, RoutineName); Real64 LatentHeatSteam = EnthSteamIn - EnthSteamOut; Real64 CpCondensate = - Fluid::GetSpecificHeatGlycol(*state, thisSteamLoop.FluidName, SatTempAtmPress, thisSteamLoop.FluidIndex, RoutineName); + FluidProperties::GetSpecificHeatGlycol(*state, thisSteamLoop.FluidName, SatTempAtmPress, thisSteamLoop.FluidIndex, RoutineName); Real64 calOutletMdot = curLoad / (LatentHeatSteam + thisLoadProfileSteamLoop.DegOfSubcooling * CpCondensate); EXPECT_EQ(thisLoadProfileSteamLoop.MassFlowRate, calOutletMdot); diff --git a/tst/EnergyPlus/unit/SetPointManager.unit.cc b/tst/EnergyPlus/unit/SetPointManager.unit.cc index 1a2f04c9997..26e18a0a647 100644 --- a/tst/EnergyPlus/unit/SetPointManager.unit.cc +++ b/tst/EnergyPlus/unit/SetPointManager.unit.cc @@ -189,8 +189,8 @@ TEST_F(EnergyPlusFixture, SetPointManager_DefineReturnWaterChWSetPointManager_Fl ASSERT_TRUE(process_idf(idf_objects)); - EXPECT_EQ(2, state->dataFluid->NumOfGlycols); - const auto &thisGlycol = state->dataFluid->GlycolData(2); + EXPECT_EQ(2, state->dataFluidProperties->NumOfGlycols); + const auto &thisGlycol = state->dataFluidProperties->GlycolData(2); EXPECT_EQ("ETHYLENEGLYCOL40PERCENT", thisGlycol.Name); EXPECT_EQ("ETHYLENEGLYCOL", thisGlycol.GlycolName); diff --git a/tst/EnergyPlus/unit/UnitHeater.unit.cc b/tst/EnergyPlus/unit/UnitHeater.unit.cc index 3d53f4424c6..8d673096237 100644 --- a/tst/EnergyPlus/unit/UnitHeater.unit.cc +++ b/tst/EnergyPlus/unit/UnitHeater.unit.cc @@ -1151,12 +1151,12 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest) EXPECT_FALSE(ErrorsFound); HWMaxVolFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; - HWDensity = Fluid::GetDensityGlycol(*state, + HWDensity = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, "xxx"); - CpHW = Fluid::GetSpecificHeatGlycol(*state, + CpHW = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, @@ -1398,7 +1398,7 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) EXPECT_NEAR(UHHeatingRate, state->dataUnitHeaters->UnitHeat(UnitHeatNum).HeatPower, ConvTol); // verify the heat rate delivered by the hot water heating coil HWMassFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; - CpHW = Fluid::GetSpecificHeatGlycol(*state, + CpHW = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, 60.0, state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 41ce3190923..af593caa68e 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -382,7 +382,7 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = state->dataWaterCoils->WaterCoil(CoilNum).Name; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; createCoilSelectionReportObj(*state); WaterCoils::SizeWaterCoil(*state, CoilNum); diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 0d0fdbd31be..b0fcbe41a92 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -228,7 +228,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; createCoilSelectionReportObj(*state); SizeWaterCoil(*state, CoilNum); @@ -463,7 +463,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -491,9 +491,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -619,7 +619,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -647,9 +647,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -779,7 +779,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -807,9 +807,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); @@ -899,7 +899,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -921,9 +921,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (state->dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp * Cp * rho); @@ -1017,7 +1017,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1038,9 +1038,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); // check cooling coil design water flow rate @@ -1142,7 +1142,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; OutputReportPredefined::SetPredefinedTables(*state); @@ -1165,9 +1165,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); // check cooling coil design water flow rate @@ -1298,7 +1298,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 10.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1320,9 +1320,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) Real64 rho = 0; Real64 DesWaterFlowRate = 0; - Cp = Fluid::GetSpecificHeatGlycol( + Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol( + rho = FluidProperties::GetDensityGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::HWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (11.0 * Cp * rho); @@ -1394,7 +1394,7 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluid->NumOfGlycols = 1; + state->dataFluidProperties->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -1422,8 +1422,8 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) Real64 DesWaterFlowRate(0.0); // now size heating coil hot water flow rate at 60.0C - Cp = Fluid::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = Fluid::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + rho = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = DesCoilHeatingLoad / (state->dataSize->PlantSizData(1).DeltaT * Cp * rho); // check heating coil design water flow rate calculated here and sizing results are identical diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc index ae221acb93a..4f734dad428 100644 --- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc +++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc @@ -771,7 +771,7 @@ TEST_F(EnergyPlusFixture, HPWHEnergyBalance) state->dataWaterThermalTanks->mdotAir = 0.0993699992873531; int GlycolIndex = 0; - const Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, Fluid::Water, Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); + const Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, FluidProperties::Water, Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); Tank.CalcHeatPumpWaterHeater(*state, false); @@ -2016,7 +2016,7 @@ TEST_F(EnergyPlusFixture, StratifiedTankCalc) auto &node = Tank.Node[i]; TankNodeEnergy += node.Mass * (NodeTemps[i] - PrevNodeTemps[i]); } - Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); TankNodeEnergy *= Cp; EXPECT_NEAR(Tank.NetHeatTransferRate * state->dataHVACGlobal->TimeStepSysSec, TankNodeEnergy, fabs(TankNodeEnergy * 0.0001)); @@ -2155,7 +2155,7 @@ TEST_F(EnergyPlusFixture, StratifiedTankSourceFlowRateCalc) Tank.SourceMassFlowRate = 6.30901964e-5 * 997; // 1 gal/min int DummyIndex = 1; - Real64 Cp = Fluid::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); + Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, "WATER", 60.0, DummyIndex, "StratifiedTankCalcNoDraw"); Tank.CalcWaterThermalTankStratified(*state); @@ -3132,7 +3132,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_Multispeed_Coil_Test) TEST_F(EnergyPlusFixture, MixedTankAlternateSchedule) { - using Fluid::GetDensityGlycol; + using FluidProperties::GetDensityGlycol; std::string const idf_objects = delimited_string({ "Schedule:Constant, Inlet Water Temperature, , 10.0;", @@ -3220,7 +3220,7 @@ TEST_F(EnergyPlusFixture, MixedTankAlternateSchedule) // Source side is in the demand side of the plant loop Tank.SrcSidePlantLoc.loopSideNum = EnergyPlus::DataPlant::LoopSideLocation::Demand; Tank.SavedSourceOutletTemp = 60.0; - rho = Fluid::GetDensityGlycol(*state, "Water", Tank.TankTemp, WaterIndex, "MixedTankAlternateSchedule"); + rho = FluidProperties::GetDensityGlycol(*state, "Water", Tank.TankTemp, WaterIndex, "MixedTankAlternateSchedule"); // Set the available max flow rates for tank and node Tank.PlantSourceMassFlowRateMax = Tank.SourceDesignVolFlowRate * rho; diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc index 7a3b1236092..31e6a5e59c0 100644 --- a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc @@ -137,61 +137,63 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) ASSERT_TRUE(process_idf(idf_objects)); - state->dataFluid->RefrigData.allocate(1); - state->dataFluid->RefrigData(1).Name = "R22"; - state->dataFluid->RefrigData(1).PsLowTempIndex = 1; - state->dataFluid->RefrigData(1).PsHighTempIndex = 2; - state->dataFluid->RefrigData(1).PsTemps.allocate(2); - state->dataFluid->RefrigData(1).PsTemps(1) = -157.42; - state->dataFluid->RefrigData(1).PsTemps(2) = 96.145; - state->dataFluid->RefrigData(1).PsValues.allocate(2); - state->dataFluid->RefrigData(1).PsValues(1) = 0.3795; - state->dataFluid->RefrigData(1).PsValues(2) = 4990000.0; - - state->dataFluid->RefrigData(1).HfLowTempIndex = 1; - state->dataFluid->RefrigData(1).HfHighTempIndex = 2; - state->dataFluid->RefrigData(1).PsLowPresIndex = 1; - state->dataFluid->RefrigData(1).PsHighPresIndex = 2; - state->dataFluid->RefrigData(1).HTemps.allocate(2); - state->dataFluid->RefrigData(1).HfValues.allocate(2); - state->dataFluid->RefrigData(1).HfgValues.allocate(2); - - state->dataFluid->RefrigData(1).HTemps(1) = -157.42; - state->dataFluid->RefrigData(1).HTemps(2) = 96.145; - state->dataFluid->RefrigData(1).HfValues(1) = 29600.0; - state->dataFluid->RefrigData(1).HfValues(2) = 366900.0; - state->dataFluid->RefrigData(1).HfgValues(1) = 332700.0; - state->dataFluid->RefrigData(1).HfgValues(2) = 366900.0; - state->dataFluid->RefrigData(1).NumSuperTempPts = 2; - state->dataFluid->RefrigData(1).NumSuperPressPts = 2; - state->dataFluid->RefrigData(1).SHTemps.allocate(2); - state->dataFluid->RefrigData(1).SHPress.allocate(2); - state->dataFluid->RefrigData(1).SHTemps(1) = -157.15; - state->dataFluid->RefrigData(1).SHTemps(2) = 152.85; - state->dataFluid->RefrigData(1).SHPress(1) = 0.4043; - state->dataFluid->RefrigData(1).SHPress(2) = 16500000.0; - state->dataFluid->RefrigData(1).HshValues.allocate(2, 2); - state->dataFluid->RefrigData(1).HshValues(1, 1) = 332800.0; - state->dataFluid->RefrigData(1).HshValues(1, 2) = 537000.0; - state->dataFluid->RefrigData(1).HshValues(2, 1) = 332800.0; - state->dataFluid->RefrigData(1).HshValues(2, 2) = 537000.0; - state->dataFluid->RefrigData(1).RhoshValues.allocate(2, 2); - state->dataFluid->RefrigData(1).RhoshValues(1, 1) = 0.00003625; - state->dataFluid->RefrigData(1).RhoshValues(1, 2) = 0.0; - state->dataFluid->RefrigData(1).RhoshValues(2, 1) = 0.00003625; - state->dataFluid->RefrigData(1).RhoshValues(2, 2) = 0.0; - - state->dataFluid->RefrigData(1).RhofLowTempIndex = 1; - state->dataFluid->RefrigData(1).RhofHighTempIndex = 2; - state->dataFluid->RefrigData(1).RhoTemps.allocate(2); - state->dataFluid->RefrigData(1).RhoTemps(1) = -157.42; - state->dataFluid->RefrigData(1).RhoTemps(2) = 96.145; - state->dataFluid->RefrigData(1).RhofValues.allocate(2); - state->dataFluid->RefrigData(1).RhofValues(1) = 1721.0; - state->dataFluid->RefrigData(1).RhofValues(2) = 523.8; - state->dataFluid->RefrigData(1).RhofgValues.allocate(2); - state->dataFluid->RefrigData(1).RhofgValues(1) = 0.341; - state->dataFluid->RefrigData(1).RhofgValues(2) = 523.8; + state->dataFluidProperties->RefrigData.allocate(1); + auto &refrig = state->dataFluidProperties->RefrigData(1); + refrig.Name = "R22"; + refrig.Num = 1; + refrig.PsLowTempIndex = 1; + refrig.PsHighTempIndex = 2; + refrig.PsTemps.allocate(2); + refrig.PsTemps(1) = -157.42; + refrig.PsTemps(2) = 96.145; + refrig.PsValues.allocate(2); + refrig.PsValues(1) = 0.3795; + refrig.PsValues(2) = 4990000.0; + + refrig.HfLowTempIndex = 1; + refrig.HfHighTempIndex = 2; + refrig.PsLowPresIndex = 1; + refrig.PsHighPresIndex = 2; + refrig.HTemps.allocate(2); + refrig.HfValues.allocate(2); + refrig.HfgValues.allocate(2); + + refrig.HTemps(1) = -157.42; + refrig.HTemps(2) = 96.145; + refrig.HfValues(1) = 29600.0; + refrig.HfValues(2) = 366900.0; + refrig.HfgValues(1) = 332700.0; + refrig.HfgValues(2) = 366900.0; + refrig.NumSuperTempPts = 2; + refrig.NumSuperPressPts = 2; + refrig.SHTemps.allocate(2); + refrig.SHPress.allocate(2); + refrig.SHTemps(1) = -157.15; + refrig.SHTemps(2) = 152.85; + refrig.SHPress(1) = 0.4043; + refrig.SHPress(2) = 16500000.0; + refrig.HshValues.allocate(2, 2); + refrig.HshValues(1, 1) = 332800.0; + refrig.HshValues(1, 2) = 537000.0; + refrig.HshValues(2, 1) = 332800.0; + refrig.HshValues(2, 2) = 537000.0; + refrig.RhoshValues.allocate(2, 2); + refrig.RhoshValues(1, 1) = 0.00003625; + refrig.RhoshValues(1, 2) = 0.0; + refrig.RhoshValues(2, 1) = 0.00003625; + refrig.RhoshValues(2, 2) = 0.0; + + refrig.RhofLowTempIndex = 1; + refrig.RhofHighTempIndex = 2; + refrig.RhoTemps.allocate(2); + refrig.RhoTemps(1) = -157.42; + refrig.RhoTemps(2) = 96.145; + refrig.RhofValues.allocate(2); + refrig.RhofValues(1) = 1721.0; + refrig.RhofValues(2) = 523.8; + refrig.RhofgValues.allocate(2); + refrig.RhofgValues(1) = 0.341; + refrig.RhofgValues(2) = 523.8; GetWatertoAirHPInput(*state); @@ -306,5 +308,5 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) // clean up state->dataWaterToAirHeatPump->WatertoAirHP.deallocate(); - state->dataFluid->RefrigData.deallocate(); + state->dataFluidProperties->RefrigData.deallocate(); } From 907bf19b5470c95c6fc429e433ed596ccf25cfbc Mon Sep 17 00:00:00 2001 From: amirroth Date: Thu, 18 Jul 2024 16:17:55 -0400 Subject: [PATCH 107/115] Some local cleanup --- src/EnergyPlus/FluidProperties.cc | 6393 ++++++++--------- src/EnergyPlus/FluidProperties.hh | 142 +- src/EnergyPlus/HVACVariableRefrigerantFlow.hh | 2 +- src/EnergyPlus/UtilityRoutines.hh | 6 + 4 files changed, 3026 insertions(+), 3517 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index c900b5e5485..870bb5e0567 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -559,14 +559,12 @@ namespace FluidProperties { // Array initializer only takes one argument. std::bind is used to convert the // actual initializer into a function of one argument. - state.dataFluidProps->NumOfRefrigerants = 0; - state.dataFluidProps->NumOfGlycols = 0; - - // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol - - + auto &df = state.dataFluidProps; + df->NumOfRefrigerants = 0; + df->NumOfGlycols = 0; + // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol Array2D DefaultSteamSuperheatedEnthalpyData(DefaultNumSteamSuperheatedPressure, DefaultNumSteamSuperheatedTemps); Array2D DefaultSteamSuperheatedDensityData(DefaultNumSteamSuperheatedPressure, DefaultNumSteamSuperheatedTemps); @@ -575,37 +573,22 @@ namespace FluidProperties { { // Members std::string Name; // Name of the temperature list - int NumOfTemps; // Number of temperatures in a particular arry + int NumOfTemps = 0; // Number of temperatures in a particular arry Array1D Temps; // Temperature values (degrees C) - - // Default Constructor - FluidTempData() : NumOfTemps(0) - { - } }; struct PressureSequence { // Members - Real64 Pressure; - int InPtr; - - // Default Constructor - PressureSequence() : Pressure(0.0), InPtr(0) - { - } + Real64 Pressure = 0.0; + int InPtr = 0; }; struct FluidData { // Members std::string Name; - bool IsGlycol; - - // Default Constructor - FluidData() : IsGlycol(false) - { - } + bool IsGlycol = false; }; // Object Data @@ -694,10 +677,10 @@ namespace FluidProperties { ++FluidNum; FluidNames(FluidNum).Name = Alphas(1); if (Util::SameString(Alphas(2), Refrig)) { - ++state.dataFluidProps->NumOfRefrigerants; + ++df->NumOfRefrigerants; FluidNames(FluidNum).IsGlycol = false; } else if (Util::SameString(Alphas(2), Glycol)) { - ++state.dataFluidProps->NumOfGlycols; + ++df->NumOfGlycols; FluidNames(FluidNum).IsGlycol = true; } else { ShowSevereError(state, format("{}{}=\"{}\", invalid type", RoutineName, CurrentModuleObject, Alphas(1))); @@ -710,78 +693,72 @@ namespace FluidProperties { ShowFatalError(state, format("{} Previous errors in input cause program termination.", RoutineName)); } - if (state.dataFluidProps->NumOfRefrigerants + 1 > 0) { - state.dataFluidProps->RefrigData.allocate(state.dataFluidProps->NumOfRefrigerants + 1); - state.dataFluidProps->RefrigUsed.allocate(state.dataFluidProps->NumOfRefrigerants + 1); - state.dataFluidProps->RefrigUsed = false; - state.dataFluidProps->RefrigErrorTracking.allocate(state.dataFluidProps->NumOfRefrigerants + 1); + if (df->NumOfRefrigerants + 1 > 0) { + df->RefrigData.allocate(df->NumOfRefrigerants + 1); } - if (state.dataFluidProps->NumOfGlycols > 0) { - state.dataFluidProps->GlyRawData.allocate(state.dataFluidProps->NumOfGlycols); + if (df->NumOfGlycols > 0) { + df->GlyRawData.allocate(df->NumOfGlycols); } // Take the fluid names and assign them to the appropriate derived type - state.dataFluidProps->NumOfRefrigerants = 1; - state.dataFluidProps->NumOfGlycols = 0; - state.dataFluidProps->RefrigData(1).Name = "STEAM"; // Steam is a refrigerant? In which universe? - state.dataFluidProps->RefrigData(1).Num = 1; - state.dataFluidProps->RefrigUsed(1) = true; - state.dataFluidProps->RefrigErrorTracking(1).Name = "STEAM"; + df->NumOfRefrigerants = 1; + df->NumOfGlycols = 0; + df->RefrigData(1).Name = "STEAM"; // Steam is a refrigerant? In which universe? + df->RefrigData(1).Num = 1; + df->RefrigData(1).used = 1; + for (int Loop = 1; Loop <= FluidNum; ++Loop) { if (!FluidNames(Loop).IsGlycol) { - ++state.dataFluidProps->NumOfRefrigerants; - state.dataFluidProps->RefrigData(state.dataFluidProps->NumOfRefrigerants).Name = FluidNames(Loop).Name; - state.dataFluidProps->RefrigData(state.dataFluidProps->NumOfRefrigerants).Num = state.dataFluidProps->NumOfRefrigerants; - state.dataFluidProps->RefrigErrorTracking(state.dataFluidProps->NumOfRefrigerants).Name = FluidNames(Loop).Name; + ++df->NumOfRefrigerants; + df->RefrigData(df->NumOfRefrigerants).Name = FluidNames(Loop).Name; + df->RefrigData(df->NumOfRefrigerants).Num = df->NumOfRefrigerants; } else if (FluidNames(Loop).IsGlycol) { - ++state.dataFluidProps->NumOfGlycols; - state.dataFluidProps->GlyRawData(state.dataFluidProps->NumOfGlycols).Name = FluidNames(Loop).Name; - state.dataFluidProps->GlyRawData(state.dataFluidProps->NumOfGlycols).Num = state.dataFluidProps->NumOfGlycols; + ++df->NumOfGlycols; + df->GlyRawData(df->NumOfGlycols).Name = FluidNames(Loop).Name; + df->GlyRawData(df->NumOfGlycols).Num = df->NumOfGlycols; } } FluidNames.deallocate(); - state.dataFluidProps->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumHPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; - state.dataFluidProps->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); - state.dataFluidProps->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); - - state.dataFluidProps->RefrigData(1).PsTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).PsValues = DefaultSteamPressData; - state.dataFluidProps->RefrigData(1).HTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; - state.dataFluidProps->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; - state.dataFluidProps->RefrigData(1).CpTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).CpfValues = DefaultSteamCpFluidData; - state.dataFluidProps->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; - state.dataFluidProps->RefrigData(1).RhoTemps = DefaultSteamTemps; - state.dataFluidProps->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; - state.dataFluidProps->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; - - state.dataFluidProps->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; - state.dataFluidProps->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; - state.dataFluidProps->RefrigData(1).SHTemps.allocate(state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).SHPress.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts); - state.dataFluidProps->RefrigData(1).HshValues.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts, - state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).RhoshValues.allocate(state.dataFluidProps->RefrigData(1).NumSuperPressPts, - state.dataFluidProps->RefrigData(1).NumSuperTempPts); - state.dataFluidProps->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; - state.dataFluidProps->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; - state.dataFluidProps->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; - state.dataFluidProps->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; + df->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; + df->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); + df->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).NumHPoints = DefaultNumSteamTemps; + df->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); + df->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; + df->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); + df->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; + df->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); + df->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); + df->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); + + df->RefrigData(1).PsTemps = DefaultSteamTemps; + df->RefrigData(1).PsValues = DefaultSteamPressData; + df->RefrigData(1).HTemps = DefaultSteamTemps; + df->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; + df->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; + df->RefrigData(1).CpTemps = DefaultSteamTemps; + df->RefrigData(1).CpfValues = DefaultSteamCpFluidData; + df->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; + df->RefrigData(1).RhoTemps = DefaultSteamTemps; + df->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; + df->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; + + df->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; + df->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; + df->RefrigData(1).SHTemps.allocate(df->RefrigData(1).NumSuperTempPts); + df->RefrigData(1).SHPress.allocate(df->RefrigData(1).NumSuperPressPts); + df->RefrigData(1).HshValues.allocate(df->RefrigData(1).NumSuperPressPts, df->RefrigData(1).NumSuperTempPts); + df->RefrigData(1).RhoshValues.allocate(df->RefrigData(1).NumSuperPressPts, df->RefrigData(1).NumSuperTempPts); + df->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; + df->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; + df->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; + df->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; // Read in all of the temperature arrays in the input file FluidTemps.allocate(NumOfFluidTempArrays); @@ -830,7 +807,7 @@ namespace FluidProperties { // Go through each refrigerant found in the fluid names statement and read in the data // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. - for (int Loop = 2; Loop <= state.dataFluidProps->NumOfRefrigerants; ++Loop) { + for (int Loop = 2; Loop <= df->NumOfRefrigerants; ++Loop) { // For each property, cycle through all the valid input until the proper match is found. @@ -855,7 +832,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -864,14 +841,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).PsTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumPsPoints); - state.dataFluidProps->RefrigData(Loop).PsValues.allocate(state.dataFluidProps->RefrigData(Loop).NumPsPoints); + df->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; + df->RefrigData(Loop).PsTemps.allocate(df->RefrigData(Loop).NumPsPoints); + df->RefrigData(Loop).PsValues.allocate(df->RefrigData(Loop).NumPsPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumPsPoints) { + if (NumNumbers != df->RefrigData(Loop).NumPsPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " "same number of points", @@ -879,15 +856,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # pressure points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumPsPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumPsPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; + df->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -895,7 +872,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid gas/fluid pressure input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -909,7 +886,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, // then no sat press data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", cAlphaFieldNames(2), @@ -937,7 +914,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -946,14 +923,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).HTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); - state.dataFluidProps->RefrigData(Loop).HfValues.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); + df->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; + df->RefrigData(Loop).HTemps.allocate(df->RefrigData(Loop).NumHPoints); + df->RefrigData(Loop).HfValues.allocate(df->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumHPoints) { + if (NumNumbers != df->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowSevereError(state, format("Temperature Name={}, Temperature array and saturated fluid enthalpy array must have the same " "number of points", @@ -961,15 +938,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumHPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; + df->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -977,7 +954,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -990,7 +967,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1017,7 +994,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1025,7 +1002,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for enthalpy fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1033,12 +1010,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).HfgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumHPoints); + df->RefrigData(Loop).HfgValues.allocate(df->RefrigData(Loop).NumHPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumHPoints) { + if (NumNumbers != df->RefrigData(Loop).NumHPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid enthalpy array must have " "the same number of points", @@ -1046,14 +1023,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumHPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumHPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1061,7 +1038,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid enthalpy input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1074,7 +1051,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g enthalpy data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="FluidGas".)", @@ -1103,7 +1080,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1112,14 +1089,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).CpTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); - state.dataFluidProps->RefrigData(Loop).CpfValues.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); + df->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; + df->RefrigData(Loop).CpTemps.allocate(df->RefrigData(Loop).NumCpPoints); + df->RefrigData(Loop).CpfValues.allocate(df->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != df->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowSevereError( state, format("Temperature Name={}, Temperature array and saturated fluid Cp array must have the same number of points", @@ -1127,15 +1104,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumCpPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + df->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1143,7 +1120,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1156,7 +1133,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format(R"(No Saturated Fluid Specific Heat found. Need properties to be entered with {}="SpecificHeat" and {}="Fluid".)", @@ -1184,7 +1161,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1192,7 +1169,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for specific heat fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1200,12 +1177,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).CpfgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumCpPoints); + df->RefrigData(Loop).CpfgValues.allocate(df->RefrigData(Loop).NumCpPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumCpPoints) { + if (NumNumbers != df->RefrigData(Loop).NumCpPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1214,14 +1191,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Cp points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumCpPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumCpPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1229,7 +1206,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid specific heat (Cp) input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1242,7 +1219,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g Cp data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format( @@ -1272,7 +1249,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), Fluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1281,14 +1258,14 @@ namespace FluidProperties { TempsName = FluidTemps(TempLoop).Name; // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).RhoTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); - state.dataFluidProps->RefrigData(Loop).RhofValues.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); + df->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; + df->RefrigData(Loop).RhoTemps.allocate(df->RefrigData(Loop).NumRhoPoints); + df->RefrigData(Loop).RhofValues.allocate(df->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != df->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated fluid density array must have the " "same number of points", @@ -1296,15 +1273,15 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # Density points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumRhoPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; - state.dataFluidProps->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + df->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1312,7 +1289,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1325,7 +1302,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format(R"(No Saturated Fluid Density found. Need properties to be entered with {}="Density" and {}="Fluid".)", cAlphaFieldNames(2), @@ -1352,7 +1329,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && (Util::SameString(Alphas(3), GasFluid))) { for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { @@ -1360,7 +1337,7 @@ namespace FluidProperties { if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Temperatures for density fluid and gas/fluid points are not the same"); ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); ErrorsFound = true; @@ -1368,12 +1345,12 @@ namespace FluidProperties { } // At this point, we have found the correct input line and found a match // for the temperature array. It's time to load up the local derived type. - state.dataFluidProps->RefrigData(Loop).RhofgValues.allocate(state.dataFluidProps->RefrigData(Loop).NumRhoPoints); + df->RefrigData(Loop).RhofgValues.allocate(df->RefrigData(Loop).NumRhoPoints); // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != state.dataFluidProps->RefrigData(Loop).NumRhoPoints) { + if (NumNumbers != df->RefrigData(Loop).NumRhoPoints) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Temperature Name={}, Temperature array and saturated gas/fluid density array must have the " "same number of points", @@ -1381,14 +1358,14 @@ namespace FluidProperties { ShowContinueError(state, format("Temperature # points={} whereas {} # density points={}", NumNumbers, - state.dataFluidProps->RefrigData(Loop).Name, - state.dataFluidProps->RefrigData(Loop).NumRhoPoints)); + df->RefrigData(Loop).Name, + df->RefrigData(Loop).NumRhoPoints)); ErrorsFound = true; break; // the TempLoop DO Loop } // Same number of points so assign the values - state.dataFluidProps->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); + df->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); break; // the TempLoop DO loop } @@ -1396,7 +1373,7 @@ namespace FluidProperties { // If it made it all the way to the last temperature array and didn't find a match, then no match was found if (TempLoop == NumOfFluidTempArrays) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Found saturated gas/fluid density input but no matching temperature array"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1409,7 +1386,7 @@ namespace FluidProperties { // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g density data found if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowSevereError( state, format(R"(No Saturated Gas/Fluid Density found. Need properties to be entered with {}="Density" and {}="FluidGas".)", @@ -1465,7 +1442,7 @@ namespace FluidProperties { !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}", "{}".)", Enthalpy, SpecificHeat, Density)); @@ -1480,7 +1457,7 @@ namespace FluidProperties { !Util::SameString(Alphas(2), SpecificHeat) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError( state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, @@ -1492,7 +1469,7 @@ namespace FluidProperties { } else { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(3), Alphas(3))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Fluid, GasFluid)); ShowContinueError(state, @@ -1529,7 +1506,7 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1537,7 +1514,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1546,7 +1523,7 @@ namespace FluidProperties { } } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "No pressure data found for superheated enthalpy"); ErrorsFound = true; } @@ -1555,13 +1532,13 @@ namespace FluidProperties { // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->RefrigData(Loop).SHTemps.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); - state.dataFluidProps->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; + df->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; + df->RefrigData(Loop).SHTemps.allocate(df->RefrigData(Loop).NumSuperTempPts); + df->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with superheated enthalpy data"); ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); ErrorsFound = true; @@ -1569,10 +1546,10 @@ namespace FluidProperties { } // Next, allocate the pressure related arrays - state.dataFluidProps->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; - state.dataFluidProps->RefrigData(Loop).SHPress.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts); - state.dataFluidProps->RefrigData(Loop).HshValues.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts, - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); + df->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; + df->RefrigData(Loop).SHPress.allocate(df->RefrigData(Loop).NumSuperPressPts); + df->RefrigData(Loop).HshValues.allocate(df->RefrigData(Loop).NumSuperPressPts, + df->RefrigData(Loop).NumSuperTempPts); // Finally, get the pressure and enthalpy values from the user input CurrentModuleObject = "FluidProperties:Superheated"; @@ -1592,10 +1569,10 @@ namespace FluidProperties { cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1633,27 +1610,27 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - state.dataFluidProps->RefrigData(Loop).SHPress(InData) = Numbers(1); + df->RefrigData(Loop).SHPress(InData) = Numbers(1); // a little error trapping if (InData > 1) { - if (state.dataFluidProps->RefrigData(Loop).SHPress(InData) <= state.dataFluidProps->RefrigData(Loop).SHPress(InData - 1)) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (df->RefrigData(Loop).SHPress(InData) <= df->RefrigData(Loop).SHPress(InData - 1)) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Pressures must be entered in ascending order for fluid property data"); ShowContinueError(state, format("First Occurrence at Pressure({}) {{{:.3R}}} >= Pressure({}) {{{:.3R}}}", InData - 1, - state.dataFluidProps->RefrigData(Loop).SHPress(InData - 1), + df->RefrigData(Loop).SHPress(InData - 1), InData, - state.dataFluidProps->RefrigData(Loop).SHPress(InData))); + df->RefrigData(Loop).SHPress(InData))); ErrorsFound = true; break; } } - if ((NumNumbers - 1) == state.dataFluidProps->RefrigData(Loop).NumSuperTempPts) { - state.dataFluidProps->RefrigData(Loop).HshValues(InData, {1, state.dataFluidProps->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == df->RefrigData(Loop).NumSuperTempPts) { + df->RefrigData(Loop).HshValues(InData, {1, df->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated enthalpy data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1665,8 +1642,8 @@ namespace FluidProperties { // First find the number of pressure value syntax lines have been entered and // make sure that all of the pressure input is linked to the same temperature list // Then allocate the arrays and read the data into the proper place - state.dataFluidProps->RefrigData(Loop).RhoshValues.allocate(state.dataFluidProps->RefrigData(Loop).NumSuperPressPts, - state.dataFluidProps->RefrigData(Loop).NumSuperTempPts); + df->RefrigData(Loop).RhoshValues.allocate(df->RefrigData(Loop).NumSuperPressPts, + df->RefrigData(Loop).NumSuperTempPts); CurrentModuleObject = "FluidProperties:Superheated"; NumOfPressPts = 0; PressurePtr.allocate(NumOfSHFluidPropArrays); @@ -1683,10 +1660,10 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfPressPts; if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; } @@ -1724,21 +1701,21 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if (std::abs(Numbers(1) - state.dataFluidProps->RefrigData(Loop).SHPress(InData)) > PressToler) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (std::abs(Numbers(1) - df->RefrigData(Loop).SHPress(InData)) > PressToler) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same refrigerant must use the same pressure data"); ErrorsFound = true; } if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); ErrorsFound = true; } - if ((NumNumbers - 1) == state.dataFluidProps->RefrigData(Loop).NumSuperTempPts) { - state.dataFluidProps->RefrigData(Loop).RhoshValues(InData, {1, state.dataFluidProps->RefrigData(Loop).NumSuperTempPts}) = + if ((NumNumbers - 1) == df->RefrigData(Loop).NumSuperTempPts) { + df->RefrigData(Loop).RhoshValues(InData, {1, df->RefrigData(Loop).NumSuperTempPts}) = Numbers({2, NumNumbers}); } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, "Number of superheated density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1766,7 +1743,7 @@ namespace FluidProperties { if (!Util::SameString(Alphas(2), Enthalpy) && !Util::SameString(Alphas(2), Density)) { if (iTemp == 0) { ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(2), Alphas(2))); ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Enthalpy, Density)); ShowContinueError(state, format("Pressure value of this item=[{:.2R}].", Numbers(1))); @@ -1781,12 +1758,12 @@ namespace FluidProperties { } if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowSevereError(state, "No pressure data found for superheated density"); ErrorsFound = true; } - if (NumOfPressPts != state.dataFluidProps->RefrigData(Loop).NumSuperPressPts) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->RefrigData(Loop).Name)); + if (NumOfPressPts != df->RefrigData(Loop).NumSuperPressPts) { + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); ShowSevereError(state, "Number of pressure points for superheated data different for enthalpy and density"); ErrorsFound = true; } @@ -1798,7 +1775,7 @@ namespace FluidProperties { // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. CurrentModuleObject = "FluidProperties:Concentration"; - for (int Loop = 1; Loop <= state.dataFluidProps->NumOfGlycols; ++Loop) { + for (int Loop = 1; Loop <= df->NumOfGlycols; ++Loop) { // Get: ***** SPECIFIC HEAT of GLYCOLS ***** // First find the number of concentration value syntax lines have been entered and @@ -1806,7 +1783,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; int NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).CpDataPresent = false; + df->GlyRawData(Loop).CpDataPresent = false; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, @@ -1820,7 +1797,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1828,7 +1805,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol specific heat data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1839,26 +1816,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).CpDataPresent = true; + df->GlyRawData(Loop).CpDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).CpTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpTempPts); - state.dataFluidProps->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; + df->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; + df->GlyRawData(Loop).CpTemps.allocate(df->GlyRawData(Loop).NumCpTempPts); + df->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the specific heat related arrays - state.dataFluidProps->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CpConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpConcPts); - state.dataFluidProps->GlyRawData(Loop).CpValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumCpConcPts, - state.dataFluidProps->GlyRawData(Loop).NumCpTempPts); + df->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; + df->GlyRawData(Loop).CpConcs.allocate(df->GlyRawData(Loop).NumCpConcPts); + df->GlyRawData(Loop).CpValues.allocate(df->GlyRawData(Loop).NumCpConcPts, + df->GlyRawData(Loop).NumCpTempPts); // Finally, get the specific heat and concentration values from the user input CurrentModuleObject = "FluidProperties:Concentration"; @@ -1876,32 +1853,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); + df->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { + if (df->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { + if (df->GlyRawData(Loop).CpConcs(NumOfConcPts) <= + df->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumCpTempPts) { - state.dataFluidProps->GlyRawData(Loop).CpValues(NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumCpTempPts}) = + if ((NumNumbers - 1) == df->GlyRawData(Loop).NumCpTempPts) { + df->GlyRawData(Loop).CpValues(NumOfConcPts, {1, df->GlyRawData(Loop).NumCpTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of specific heat data points not equal to number of temperature points"); ErrorsFound = true; } @@ -1914,7 +1891,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).RhoDataPresent = false; + df->GlyRawData(Loop).RhoDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for density are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1929,7 +1906,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -1937,7 +1914,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol density data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -1948,26 +1925,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).RhoDataPresent = true; + df->GlyRawData(Loop).RhoDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).RhoTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts); - state.dataFluidProps->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; + df->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; + df->GlyRawData(Loop).RhoTemps.allocate(df->GlyRawData(Loop).NumRhoTempPts); + df->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the density related arrays - state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).RhoConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts); - state.dataFluidProps->GlyRawData(Loop).RhoValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumRhoConcPts, - state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts); + df->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; + df->GlyRawData(Loop).RhoConcs.allocate(df->GlyRawData(Loop).NumRhoConcPts); + df->GlyRawData(Loop).RhoValues.allocate(df->GlyRawData(Loop).NumRhoConcPts, + df->GlyRawData(Loop).NumRhoTempPts); // Finally, get the density and concentration values from the user input NumOfConcPts = 0; @@ -1985,32 +1962,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); + df->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { + if (df->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { + if (df->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= + df->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts) { - state.dataFluidProps->GlyRawData(Loop).RhoValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == df->GlyRawData(Loop).NumRhoTempPts) { + df->GlyRawData(Loop).RhoValues( + NumOfConcPts, {1, df->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of density data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2023,7 +2000,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).CondDataPresent = false; + df->GlyRawData(Loop).CondDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for conductivity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2038,7 +2015,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2046,7 +2023,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol conductivity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2057,26 +2034,26 @@ namespace FluidProperties { if (NumOfConcPts > 0) { // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array - state.dataFluidProps->GlyRawData(Loop).CondDataPresent = true; + df->GlyRawData(Loop).CondDataPresent = true; for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).CondTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondTempPts); - state.dataFluidProps->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; + df->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; + df->GlyRawData(Loop).CondTemps.allocate(df->GlyRawData(Loop).NumCondTempPts); + df->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the conductivity related arrays - state.dataFluidProps->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CondConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondConcPts); - state.dataFluidProps->GlyRawData(Loop).CondValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumCondConcPts, - state.dataFluidProps->GlyRawData(Loop).NumCondTempPts); + df->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; + df->GlyRawData(Loop).CondConcs.allocate(df->GlyRawData(Loop).NumCondConcPts); + df->GlyRawData(Loop).CondValues.allocate(df->GlyRawData(Loop).NumCondConcPts, + df->GlyRawData(Loop).NumCondTempPts); // Finally, get the conductivity and concentration values from the user input NumOfConcPts = 0; @@ -2094,32 +2071,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); + df->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { + if (df->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { + if (df->GlyRawData(Loop).CondConcs(NumOfConcPts) <= + df->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumCondTempPts) { - state.dataFluidProps->GlyRawData(Loop).CondValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == df->GlyRawData(Loop).NumCondTempPts) { + df->GlyRawData(Loop).CondValues( + NumOfConcPts, {1, df->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of conductivity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2132,7 +2109,7 @@ namespace FluidProperties { TempsName = ""; FirstSHMatch = true; NumOfConcPts = 0; - state.dataFluidProps->GlyRawData(Loop).ViscDataPresent = false; + df->GlyRawData(Loop).ViscDataPresent = false; CurrentModuleObject = "FluidProperties:Concentration"; for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for viscosity are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2147,7 +2124,7 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; if (FirstSHMatch) { TempsName = Alphas(3); @@ -2155,7 +2132,7 @@ namespace FluidProperties { } else { if (!Util::SameString(TempsName, Alphas(3))) { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "All glycol viscosity data for the same glycol must use the same temperature list"); ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); ErrorsFound = true; @@ -2164,28 +2141,28 @@ namespace FluidProperties { } } if (NumOfConcPts > 0) { - state.dataFluidProps->GlyRawData(Loop).ViscDataPresent = true; + df->GlyRawData(Loop).ViscDataPresent = true; // Now allocate the arrays and read the data into the proper place // First, allocate the temperature array and transfer the data from the FluidTemp array for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - state.dataFluidProps->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; - state.dataFluidProps->GlyRawData(Loop).ViscTemps.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscTempPts); - state.dataFluidProps->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; + df->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; + df->GlyRawData(Loop).ViscTemps.allocate(df->GlyRawData(Loop).NumViscTempPts); + df->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; break; // the TempLoop DO loop } if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "No match for temperature array name found with glycol data"); ErrorsFound = true; } } // Next, allocate the viscosity related arrays - state.dataFluidProps->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).ViscConcs.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscConcPts); - state.dataFluidProps->GlyRawData(Loop).ViscValues.allocate(state.dataFluidProps->GlyRawData(Loop).NumViscConcPts, - state.dataFluidProps->GlyRawData(Loop).NumViscTempPts); + df->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; + df->GlyRawData(Loop).ViscConcs.allocate(df->GlyRawData(Loop).NumViscConcPts); + df->GlyRawData(Loop).ViscValues.allocate(df->GlyRawData(Loop).NumViscConcPts, + df->GlyRawData(Loop).NumViscTempPts); // Finally, get the viscosity and concentration values from the user input NumOfConcPts = 0; @@ -2203,32 +2180,32 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFieldNames, cNumericFieldNames); - if ((Util::SameString(Alphas(1), state.dataFluidProps->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { + if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { ++NumOfConcPts; - state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); + df->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); // a little error trapping if (NumOfConcPts == 1) { - if (state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { + if (df->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; } } else { - if (state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= - state.dataFluidProps->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { + if (df->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= + df->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); ErrorsFound = true; } } - if ((NumNumbers - 1) == state.dataFluidProps->GlyRawData(Loop).NumViscTempPts) { - state.dataFluidProps->GlyRawData(Loop).ViscValues( - NumOfConcPts, {1, state.dataFluidProps->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); + if ((NumNumbers - 1) == df->GlyRawData(Loop).NumViscTempPts) { + df->GlyRawData(Loop).ViscValues( + NumOfConcPts, {1, df->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); } else { ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, state.dataFluidProps->GlyRawData(Loop).Name)); + format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); ShowContinueError(state, "Number of viscosity data points not equal to number of temperature points"); ErrorsFound = true; } @@ -2269,40 +2246,39 @@ namespace FluidProperties { NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); int NumOfGlyConcs = NumOfOptionalInput + 1; - state.dataFluidProps->GlycolData.allocate(NumOfGlyConcs); - state.dataFluidProps->GlycolUsed.dimension(NumOfGlyConcs, false); + df->GlycolData.allocate(NumOfGlyConcs); - state.dataFluidProps->GlycolUsed(1) = true; // mark Water as always used + df->GlycolData(1).used = true; // mark Water as always used // First "glycol" is always pure water. Load data from default arrays - state.dataFluidProps->GlycolData(1).Name = "WATER"; - state.dataFluidProps->GlycolData(1).GlycolName = "WATER"; - state.dataFluidProps->GlycolData(1).Num = 1; - state.dataFluidProps->GlycolData(1).Concentration = 1.0; - state.dataFluidProps->GlycolData(1).CpDataPresent = true; - state.dataFluidProps->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).RhoDataPresent = true; - state.dataFluidProps->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).CondDataPresent = true; - state.dataFluidProps->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).ViscDataPresent = true; - state.dataFluidProps->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(1).CpTemps.allocate(state.dataFluidProps->GlycolData(1).NumCpTempPts); - state.dataFluidProps->GlycolData(1).CpValues.allocate(state.dataFluidProps->GlycolData(1).NumCpTempPts); - state.dataFluidProps->GlycolData(1).RhoTemps.allocate(state.dataFluidProps->GlycolData(1).NumRhoTempPts); - state.dataFluidProps->GlycolData(1).RhoValues.allocate(state.dataFluidProps->GlycolData(1).NumRhoTempPts); - state.dataFluidProps->GlycolData(1).CondTemps.allocate(state.dataFluidProps->GlycolData(1).NumCondTempPts); - state.dataFluidProps->GlycolData(1).CondValues.allocate(state.dataFluidProps->GlycolData(1).NumCondTempPts); - state.dataFluidProps->GlycolData(1).ViscTemps.allocate(state.dataFluidProps->GlycolData(1).NumViscTempPts); - state.dataFluidProps->GlycolData(1).ViscValues.allocate(state.dataFluidProps->GlycolData(1).NumViscTempPts); - state.dataFluidProps->GlycolData(1).CpTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).CpValues = DefaultWaterCpData; - state.dataFluidProps->GlycolData(1).RhoTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).RhoValues = DefaultWaterRhoData; - state.dataFluidProps->GlycolData(1).CondTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).CondValues = DefaultWaterCondData; - state.dataFluidProps->GlycolData(1).ViscTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(1).ViscValues = DefaultWaterViscData; + df->GlycolData(1).Name = "WATER"; + df->GlycolData(1).GlycolName = "WATER"; + df->GlycolData(1).Num = 1; + df->GlycolData(1).Concentration = 1.0; + df->GlycolData(1).CpDataPresent = true; + df->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; + df->GlycolData(1).RhoDataPresent = true; + df->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; + df->GlycolData(1).CondDataPresent = true; + df->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; + df->GlycolData(1).ViscDataPresent = true; + df->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; + df->GlycolData(1).CpTemps.allocate(df->GlycolData(1).NumCpTempPts); + df->GlycolData(1).CpValues.allocate(df->GlycolData(1).NumCpTempPts); + df->GlycolData(1).RhoTemps.allocate(df->GlycolData(1).NumRhoTempPts); + df->GlycolData(1).RhoValues.allocate(df->GlycolData(1).NumRhoTempPts); + df->GlycolData(1).CondTemps.allocate(df->GlycolData(1).NumCondTempPts); + df->GlycolData(1).CondValues.allocate(df->GlycolData(1).NumCondTempPts); + df->GlycolData(1).ViscTemps.allocate(df->GlycolData(1).NumViscTempPts); + df->GlycolData(1).ViscValues.allocate(df->GlycolData(1).NumViscTempPts); + df->GlycolData(1).CpTemps = DefaultGlycolTemps; + df->GlycolData(1).CpValues = DefaultWaterCpData; + df->GlycolData(1).RhoTemps = DefaultGlycolTemps; + df->GlycolData(1).RhoValues = DefaultWaterRhoData; + df->GlycolData(1).CondTemps = DefaultGlycolTemps; + df->GlycolData(1).CondValues = DefaultWaterCondData; + df->GlycolData(1).ViscTemps = DefaultGlycolTemps; + df->GlycolData(1).ViscValues = DefaultWaterViscData; NumOfGlyConcs = 1; // Water is always available, everything else must be specified @@ -2323,28 +2299,28 @@ namespace FluidProperties { if (Util::SameString(Alphas(2), EthyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + df->GlycolData(NumOfGlyConcs).Name = Alphas(1); + df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), PropyleneGlycol)) { GlycolFound = true; ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); + df->GlycolData(NumOfGlyConcs).Name = Alphas(1); + df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); } else if (Util::SameString(Alphas(2), "UserDefinedGlycolType")) { - for (InData = 1; InData <= state.dataFluidProps->NumOfGlycols; ++InData) { - if (Util::SameString(Alphas(3), state.dataFluidProps->GlyRawData(InData).Name)) { + for (InData = 1; InData <= df->NumOfGlycols; ++InData) { + if (Util::SameString(Alphas(3), df->GlyRawData(InData).Name)) { GlycolFound = true; break; // DO LOOP through user defined glycols } } if (GlycolFound) { ++NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Name = Alphas(1); - state.dataFluidProps->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - state.dataFluidProps->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); + df->GlycolData(NumOfGlyConcs).Name = Alphas(1); + df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; + df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); } else { ShowSevereError(state, format("{}{}=\"{}\", invalid reference", RoutineName, CurrentModuleObject, Alphas(1))); ShowContinueError(state, format("... not found in the FluidProperties:Name list: \"{}\".", Alphas(3))); @@ -2357,192 +2333,183 @@ namespace FluidProperties { ErrorsFound = true; } if (!GlycolFound) continue; - state.dataFluidProps->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); + df->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); } // Now initialize the rest of the data for the glycols for (int Loop = 2; Loop <= NumOfGlyConcs; ++Loop) { + auto &glycol = df->GlycolData(Loop); + // Check to see if glycol name is one of the defaults or is listed in the Fluid Name list - if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, EthyleneGlycol)) { - state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex = EthyleneGlycolIndex; - } else if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, PropyleneGlycol)) { - state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex = PropyleneGlycolIndex; + if (Util::SameString(glycol.GlycolName, EthyleneGlycol)) { + glycol.BaseGlycolIndex = EthyleneGlycolIndex; + } else if (Util::SameString(glycol.GlycolName, PropyleneGlycol)) { + glycol.BaseGlycolIndex = PropyleneGlycolIndex; } else { - for (InData = 1; InData <= state.dataFluidProps->NumOfGlycols; ++InData) { - if (Util::SameString(state.dataFluidProps->GlycolData(Loop).GlycolName, state.dataFluidProps->GlyRawData(InData).Name)) { - state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex = InData; + for (InData = 1; InData <= df->NumOfGlycols; ++InData) { + if (Util::SameString(glycol.GlycolName, df->GlyRawData(InData).Name)) { + glycol.BaseGlycolIndex = InData; break; // DO LOOP through user defined glycols } } } // Set the rest of the parameters... - if ((state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex == EthyleneGlycolIndex) || - (state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex == PropyleneGlycolIndex)) { - - state.dataFluidProps->GlycolData(Loop).CpDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCpTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).RhoDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumRhoTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).CondDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCondTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).ViscDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumViscTempPts = DefaultNumGlyTemps; - state.dataFluidProps->GlycolData(Loop).CpTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoValues.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).CondTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscValues.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).CpTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).RhoTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).CondTemps = DefaultGlycolTemps; - state.dataFluidProps->GlycolData(Loop).ViscTemps = DefaultGlycolTemps; + if ((glycol.BaseGlycolIndex == EthyleneGlycolIndex) || + (glycol.BaseGlycolIndex == PropyleneGlycolIndex)) { + + glycol.CpDataPresent = true; + glycol.NumCpTempPts = DefaultNumGlyTemps; + glycol.RhoDataPresent = true; + glycol.NumRhoTempPts = DefaultNumGlyTemps; + glycol.CondDataPresent = true; + glycol.NumCondTempPts = DefaultNumGlyTemps; + glycol.ViscDataPresent = true; + glycol.NumViscTempPts = DefaultNumGlyTemps; + glycol.CpTemps.allocate(glycol.NumCpTempPts); + glycol.CpValues.allocate(glycol.NumCpTempPts); + glycol.RhoTemps.allocate(glycol.NumRhoTempPts); + glycol.RhoValues.allocate(glycol.NumRhoTempPts); + glycol.CondTemps.allocate(glycol.NumCondTempPts); + glycol.CondValues.allocate(glycol.NumCondTempPts); + glycol.ViscTemps.allocate(glycol.NumViscTempPts); + glycol.ViscValues.allocate(glycol.NumViscTempPts); + glycol.CpTemps = DefaultGlycolTemps; + glycol.RhoTemps = DefaultGlycolTemps; + glycol.CondTemps = DefaultGlycolTemps; + glycol.ViscTemps = DefaultGlycolTemps; - if (state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex == EthyleneGlycolIndex) { - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultEthGlyCpData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultEthGlyRhoData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + if (glycol.BaseGlycolIndex == EthyleneGlycolIndex) { + InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCpData, glycol.Concentration, glycol.CpValues); + InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyRhoData, glycol.Concentration, glycol.RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCondData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + glycol.Concentration, + glycol.CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyViscData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + glycol.Concentration, + glycol.ViscValues); } else { // == PropyleneGlycolIndex InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCpData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); + glycol.Concentration, + glycol.CpValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyRhoData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + glycol.Concentration, + glycol.RhoValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyCondData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + glycol.Concentration, + glycol.CondValues); InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultPropGlyViscData, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + glycol.Concentration, + glycol.ViscValues); } } else { // User-defined fluid - int Index = state.dataFluidProps->GlycolData(Loop).BaseGlycolIndex; + int Index = glycol.BaseGlycolIndex; // Specific heat data: - if (state.dataFluidProps->GlyRawData(Index).CpDataPresent) { - state.dataFluidProps->GlycolData(Loop).CpDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCpTempPts = state.dataFluidProps->GlyRawData(Index).NumCpTempPts; - state.dataFluidProps->GlycolData(Loop).CpTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCpTempPts); - state.dataFluidProps->GlycolData(Loop).CpTemps = state.dataFluidProps->GlyRawData(Index).CpTemps; + if (df->GlyRawData(Index).CpDataPresent) { + glycol.CpDataPresent = true; + glycol.NumCpTempPts = df->GlyRawData(Index).NumCpTempPts; + glycol.CpTemps.allocate(glycol.NumCpTempPts); + glycol.CpValues.allocate(glycol.NumCpTempPts); + glycol.CpTemps = df->GlyRawData(Index).CpTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumCpConcPts, - state.dataFluidProps->GlyRawData(Index).NumCpTempPts, - state.dataFluidProps->GlyRawData(Index).CpConcs, - state.dataFluidProps->GlyRawData(Index).CpValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CpValues); + df->GlyRawData(Index).NumCpConcPts, + df->GlyRawData(Index).NumCpTempPts, + df->GlyRawData(Index).CpConcs, + df->GlyRawData(Index).CpValues, + glycol.Concentration, + glycol.CpValues); } else { ShowSevereError(state, format("{}Specific heat data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); ErrorsFound = true; } // Density data: - if (state.dataFluidProps->GlyRawData(Index).CpDataPresent) { - state.dataFluidProps->GlycolData(Loop).RhoDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumRhoTempPts = state.dataFluidProps->GlyRawData(Index).NumRhoTempPts; - state.dataFluidProps->GlycolData(Loop).RhoTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoValues.allocate(state.dataFluidProps->GlycolData(Loop).NumRhoTempPts); - state.dataFluidProps->GlycolData(Loop).RhoTemps = state.dataFluidProps->GlyRawData(Index).RhoTemps; + if (df->GlyRawData(Index).CpDataPresent) { + glycol.RhoDataPresent = true; + glycol.NumRhoTempPts = df->GlyRawData(Index).NumRhoTempPts; + glycol.RhoTemps.allocate(glycol.NumRhoTempPts); + glycol.RhoValues.allocate(glycol.NumRhoTempPts); + glycol.RhoTemps = df->GlyRawData(Index).RhoTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumRhoConcPts, - state.dataFluidProps->GlyRawData(Index).NumRhoTempPts, - state.dataFluidProps->GlyRawData(Index).RhoConcs, - state.dataFluidProps->GlyRawData(Index).RhoValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).RhoValues); + df->GlyRawData(Index).NumRhoConcPts, + df->GlyRawData(Index).NumRhoTempPts, + df->GlyRawData(Index).RhoConcs, + df->GlyRawData(Index).RhoValues, + glycol.Concentration, + glycol.RhoValues); } else { ShowSevereError(state, format("{}Density data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); ErrorsFound = true; } // Conductivity data: - if (state.dataFluidProps->GlyRawData(Index).CondDataPresent) { - state.dataFluidProps->GlycolData(Loop).CondDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumCondTempPts = state.dataFluidProps->GlyRawData(Index).NumCondTempPts; - state.dataFluidProps->GlycolData(Loop).CondTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondValues.allocate(state.dataFluidProps->GlycolData(Loop).NumCondTempPts); - state.dataFluidProps->GlycolData(Loop).CondTemps = state.dataFluidProps->GlyRawData(Index).CondTemps; + if (df->GlyRawData(Index).CondDataPresent) { + glycol.CondDataPresent = true; + glycol.NumCondTempPts = df->GlyRawData(Index).NumCondTempPts; + glycol.CondTemps.allocate(glycol.NumCondTempPts); + glycol.CondValues.allocate(glycol.NumCondTempPts); + glycol.CondTemps = df->GlyRawData(Index).CondTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumCondConcPts, - state.dataFluidProps->GlyRawData(Index).NumCondTempPts, - state.dataFluidProps->GlyRawData(Index).CondConcs, - state.dataFluidProps->GlyRawData(Index).CondValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).CondValues); + df->GlyRawData(Index).NumCondConcPts, + df->GlyRawData(Index).NumCondTempPts, + df->GlyRawData(Index).CondConcs, + df->GlyRawData(Index).CondValues, + glycol.Concentration, + glycol.CondValues); } else { ShowSevereError(state, format("{}Conductivity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); ErrorsFound = true; } // Viscosity data: - if (state.dataFluidProps->GlyRawData(Index).ViscDataPresent) { - state.dataFluidProps->GlycolData(Loop).ViscDataPresent = true; - state.dataFluidProps->GlycolData(Loop).NumViscTempPts = state.dataFluidProps->GlyRawData(Index).NumViscTempPts; - state.dataFluidProps->GlycolData(Loop).ViscTemps.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscValues.allocate(state.dataFluidProps->GlycolData(Loop).NumViscTempPts); - state.dataFluidProps->GlycolData(Loop).ViscTemps = state.dataFluidProps->GlyRawData(Index).ViscTemps; + if (df->GlyRawData(Index).ViscDataPresent) { + glycol.ViscDataPresent = true; + glycol.NumViscTempPts = df->GlyRawData(Index).NumViscTempPts; + glycol.ViscTemps.allocate(glycol.NumViscTempPts); + glycol.ViscValues.allocate(glycol.NumViscTempPts); + glycol.ViscTemps = df->GlyRawData(Index).ViscTemps; InterpValuesForGlycolConc(state, - state.dataFluidProps->GlyRawData(Index).NumViscConcPts, - state.dataFluidProps->GlyRawData(Index).NumViscTempPts, - state.dataFluidProps->GlyRawData(Index).ViscConcs, - state.dataFluidProps->GlyRawData(Index).ViscValues, - state.dataFluidProps->GlycolData(Loop).Concentration, - state.dataFluidProps->GlycolData(Loop).ViscValues); + df->GlyRawData(Index).NumViscConcPts, + df->GlyRawData(Index).NumViscTempPts, + df->GlyRawData(Index).ViscConcs, + df->GlyRawData(Index).ViscValues, + glycol.Concentration, + glycol.ViscValues); } else { ShowSevereError(state, format("{}Viscosity data not entered for a {}", RoutineName, CurrentModuleObject)); ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", state.dataFluidProps->GlycolData(Loop).Name)); - ShowContinueError(state, format("Glycol fluid name = {}", state.dataFluidProps->GlycolData(Loop).GlycolName)); + ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); ErrorsFound = true; } } } - state.dataFluidProps->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number - state.dataFluidProps->GlycolErrorTracking.allocate(state.dataFluidProps->NumOfGlycols); - for (std::size_t i = 0; i < state.dataFluidProps->GlycolErrorTracking.size(); ++i) - state.dataFluidProps->GlycolErrorTracking[i].Name = state.dataFluidProps->GlycolData[i].Name; + df->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols @@ -2561,1956 +2528,18 @@ namespace FluidProperties { ShowFatalError(state, format("{}Previous errors in input cause program termination.", RoutineName)); } - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) state.dataFluidProps->DebugReportGlycols = true; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) df->DebugReportGlycols = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTREFRIGERANTS") > 0) - state.dataFluidProps->DebugReportRefrigerants = true; + df->DebugReportRefrigerants = true; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEGLYCOLERRORLIMIT") > 0) - state.dataFluidProps->GlycolErrorLimitTest += 10; + df->GlycolErrorLimitTest += 10; if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEREFRIGERANTERRORLIMIT") > 0) - state.dataFluidProps->RefrigerantErrorLimitTest += 10; + df->RefrigErrorLimitTest += 10; - if (state.dataFluidProps->DebugReportGlycols) ReportAndTestGlycols(state); - if (state.dataFluidProps->DebugReportRefrigerants) ReportAndTestRefrigerants(state); + if (df->DebugReportGlycols) ReportAndTestGlycols(state); + if (df->DebugReportRefrigerants) ReportAndTestRefrigerants(state); } - [[maybe_unused]] static constexpr std::array, DefaultNumSteamSuperheatedPressure> - DefaultSteamSuperheatedEnthalpyDataTable = {{ - {2501000.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 2510000.0, 2519000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 2519000.0, 2529000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 2528000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2622000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 2537000.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, - 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2584000.0, 2594000.0, - 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2556000.0, 2565000.0, 2575000.0, 2584000.0, 2594000.0, - 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, - 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2565000.0, 2574000.0, 2584000.0, 2593000.0, - 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2661000.0, - 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2574000.0, 2583000.0, 2593000.0, - 2602000.0, 2612000.0, 2621000.0, 2631000.0, 2635000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2657000.0, 2661000.0, - 2665000.0, 2669000.0, 2673000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2582000.0, 2592000.0, - 2602000.0, 2611000.0, 2621000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2649000.0, 2653000.0, 2657000.0, 2661000.0, - 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2775000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2591000.0, - 2601000.0, 2611000.0, 2620000.0, 2630000.0, 2634000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, 2660000.0, - 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2600000.0, 2610000.0, 2620000.0, 2629000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2648000.0, 2652000.0, 2656000.0, 2660000.0, - 2664000.0, 2668000.0, 2671000.0, 2675000.0, 2679000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2692000.0, 2694000.0, - 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2715000.0, 2717000.0, - 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, 2740000.0, - 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, - 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2609000.0, 2619000.0, 2628000.0, 2632000.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2655000.0, 2659000.0, - 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, - 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, - 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, - 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2778000.0, 2782000.0, - 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2836000.0, 2840000.0, 2850000.0, 2860000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2908000.0, 2918000.0, 2928000.0, - 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3076000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2618000.0, 2627000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2659000.0, - 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, - 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2716000.0, - 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, - 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, - 2786000.0, 2790000.0, 2794000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2850000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, - 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2626000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, - 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, - 2695000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, - 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, - 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, - 2937000.0, 2957000.0, 2977000.0, 2997000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2630000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, - 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, - 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, - 2741000.0, 2743000.0, 2747000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, - 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, - 2661000.0, 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, - 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, - 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, - 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2917000.0, 2927000.0, - 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, - 2660000.0, 2664000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, - 2659000.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2646000.0, 2650000.0, 2654000.0, - 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, - 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, - 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2650000.0, 2654000.0, - 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, - 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, - 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, - 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2653000.0, - 2657000.0, 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, - 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, - 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2732000.0, 2734000.0, 2736000.0, - 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2926000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3035000.0, 3055000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2656000.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, - 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, - 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, - 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2916000.0, 2926000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, - 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, - 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2735000.0, - 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2936000.0, 2956000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, - 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, - 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, - 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2774000.0, 2778000.0, - 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2936000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2666000.0, 2670000.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, - 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, - 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, - 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, - 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, - 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2669000.0, 2673000.0, 2675000.0, 2677000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, - 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, - 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, - 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, - 2829000.0, 2833000.0, 2837000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2672000.0, 2674000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, - 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, - 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, - 2686000.0, 2688000.0, 2690000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, - 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, - 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, - 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2679000.0, 2681000.0, 2683000.0, - 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2680000.0, 2682000.0, - 2684000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, - 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2682000.0, - 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, - 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, - 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2683000.0, 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, - 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, - 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, - 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2686000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, - 2707000.0, 2709000.0, 2711000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, - 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, - 2706000.0, 2708000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, - 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, - 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2727000.0, 2729000.0, - 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, - 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, - 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2703000.0, - 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2724000.0, 2726000.0, 2728000.0, - 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, - 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, - 2729000.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2697000.0, 2699000.0, 2701000.0, - 2703000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2725000.0, 2727000.0, - 2729000.0, 2731000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2699000.0, 2701000.0, - 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, - 2728000.0, 2730000.0, 2734000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3174000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2700000.0, - 2702000.0, 2704000.0, 2706000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2726000.0, - 2728000.0, 2730000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, - 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, - 2727000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2771000.0, - 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, - 2726000.0, 2729000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, - 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2704000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, 2722000.0, 2724000.0, - 2726000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2766000.0, 2770000.0, - 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, - 2725000.0, 2727000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, - 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2707000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, - 2725000.0, 2727000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, - 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2718000.0, 2720000.0, 2722000.0, - 2724000.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, - 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, - 2723000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, 2768000.0, - 2772000.0, 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, - 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, - 2723000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, - 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2813000.0, 2817000.0, - 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2970000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, - 2722000.0, 2724000.0, 2728000.0, 2733000.0, 2737000.0, 2741000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2767000.0, - 2771000.0, 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, - 2820000.0, 2824000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2758000.0, 2762000.0, 2766000.0, - 2770000.0, 2774000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, 2816000.0, - 2820000.0, 2824000.0, 2828000.0, 2838000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, - 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3010000.0, 3031000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2716000.0, 2718000.0, - 2720000.0, 2723000.0, 2727000.0, 2731000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, - 2770000.0, 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, - 2819000.0, 2824000.0, 2828000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, - 2929000.0, 2949000.0, 2970000.0, 2990000.0, 3010000.0, 3030000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3152000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2717000.0, - 2720000.0, 2722000.0, 2726000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2761000.0, 2765000.0, - 2769000.0, 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2807000.0, 2811000.0, 2815000.0, - 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2899000.0, 2909000.0, 2919000.0, - 2929000.0, 2949000.0, 2969000.0, 2990000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2719000.0, 2721000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, - 2768000.0, 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, - 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2847000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2919000.0, - 2929000.0, 2949000.0, 2969000.0, 2989000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2720000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, - 2768000.0, 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2806000.0, 2810000.0, 2814000.0, - 2818000.0, 2822000.0, 2826000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, - 2928000.0, 2949000.0, 2969000.0, 2989000.0, 3009000.0, 3030000.0, 3050000.0, 3070000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2723000.0, 2727000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, - 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2805000.0, 2809000.0, 2813000.0, - 2817000.0, 2821000.0, 2825000.0, 2836000.0, 2846000.0, 2856000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2918000.0, - 2928000.0, 2948000.0, 2968000.0, 2989000.0, 3009000.0, 3029000.0, 3050000.0, 3070000.0, 3090000.0, 3111000.0, 3131000.0, 3152000.0, - 3172000.0, 3193000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, 2757000.0, 2761000.0, - 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, - 2816000.0, 2820000.0, 2824000.0, 2835000.0, 2845000.0, 2855000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2907000.0, 2917000.0, - 2927000.0, 2947000.0, 2968000.0, 2988000.0, 3008000.0, 3029000.0, 3049000.0, 3069000.0, 3090000.0, 3110000.0, 3131000.0, 3151000.0, - 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2728000.0, 2733000.0, 2737000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, - 2764000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, - 2815000.0, 2819000.0, 2823000.0, 2834000.0, 2844000.0, 2854000.0, 2865000.0, 2875000.0, 2885000.0, 2896000.0, 2906000.0, 2916000.0, - 2926000.0, 2947000.0, 2967000.0, 2987000.0, 3008000.0, 3028000.0, 3049000.0, 3069000.0, 3089000.0, 3110000.0, 3130000.0, 3151000.0, - 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2749000.0, 2753000.0, 2758000.0, - 2762000.0, 2767000.0, 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, - 2814000.0, 2818000.0, 2822000.0, 2833000.0, 2843000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, - 2926000.0, 2946000.0, 2966000.0, 2987000.0, 3007000.0, 3028000.0, 3048000.0, 3069000.0, 3089000.0, 3109000.0, 3130000.0, 3151000.0, - 3171000.0, 3192000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2733000.0, 2738000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, - 2761000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, - 2812000.0, 2817000.0, 2821000.0, 2831000.0, 2842000.0, 2852000.0, 2863000.0, 2873000.0, 2884000.0, 2894000.0, 2904000.0, 2915000.0, - 2925000.0, 2945000.0, 2966000.0, 2986000.0, 3007000.0, 3027000.0, 3048000.0, 3068000.0, 3089000.0, 3109000.0, 3130000.0, 3150000.0, - 3171000.0, 3191000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2736000.0, 2741000.0, 2745000.0, 2750000.0, 2754000.0, - 2759000.0, 2763000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2803000.0, 2807000.0, - 2811000.0, 2815000.0, 2820000.0, 2830000.0, 2841000.0, 2851000.0, 2862000.0, 2872000.0, 2883000.0, 2893000.0, 2903000.0, 2914000.0, - 2924000.0, 2945000.0, 2965000.0, 2986000.0, 3006000.0, 3027000.0, 3047000.0, 3068000.0, 3088000.0, 3109000.0, 3129000.0, 3150000.0, - 3170000.0, 3191000.0, 3212000.0, 3280000.0, 3379000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, - 2757000.0, 2761000.0, 2766000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, - 2810000.0, 2814000.0, 2818000.0, 2829000.0, 2840000.0, 2850000.0, 2861000.0, 2871000.0, 2882000.0, 2892000.0, 2902000.0, 2913000.0, - 2923000.0, 2944000.0, 2964000.0, 2985000.0, 3005000.0, 3026000.0, 3046000.0, 3067000.0, 3088000.0, 3108000.0, 3129000.0, 3149000.0, - 3170000.0, 3191000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2741000.0, 2746000.0, 2750000.0, - 2755000.0, 2760000.0, 2764000.0, 2769000.0, 2773000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, - 2808000.0, 2813000.0, 2817000.0, 2828000.0, 2838000.0, 2849000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2912000.0, - 2922000.0, 2943000.0, 2964000.0, 2984000.0, 3005000.0, 3025000.0, 3046000.0, 3066000.0, 3087000.0, 3108000.0, 3128000.0, 3149000.0, - 3170000.0, 3190000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2744000.0, 2748000.0, - 2753000.0, 2758000.0, 2762000.0, 2767000.0, 2771000.0, 2776000.0, 2780000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, - 2807000.0, 2811000.0, 2815000.0, 2826000.0, 2837000.0, 2848000.0, 2858000.0, 2869000.0, 2879000.0, 2890000.0, 2900000.0, 2911000.0, - 2921000.0, 2942000.0, 2963000.0, 2983000.0, 3004000.0, 3025000.0, 3045000.0, 3066000.0, 3086000.0, 3107000.0, 3128000.0, 3148000.0, - 3169000.0, 3190000.0, 3211000.0, 3280000.0, 3378000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2746000.0, - 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2801000.0, - 2805000.0, 2810000.0, 2814000.0, 2825000.0, 2836000.0, 2846000.0, 2857000.0, 2868000.0, 2878000.0, 2889000.0, 2899000.0, 2910000.0, - 2920000.0, 2941000.0, 2962000.0, 2983000.0, 3003000.0, 3024000.0, 3045000.0, 3065000.0, 3086000.0, 3106000.0, 3127000.0, 3148000.0, - 3169000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2748000.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2776000.0, 2781000.0, 2786000.0, 2790000.0, 2795000.0, 2799000.0, - 2803000.0, 2808000.0, 2812000.0, 2823000.0, 2834000.0, 2845000.0, 2856000.0, 2866000.0, 2877000.0, 2888000.0, 2898000.0, 2909000.0, - 2919000.0, 2940000.0, 2961000.0, 2982000.0, 3002000.0, 3023000.0, 3044000.0, 3064000.0, 3085000.0, 3106000.0, 3127000.0, 3147000.0, - 3168000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, - 2802000.0, 2806000.0, 2811000.0, 2822000.0, 2833000.0, 2843000.0, 2854000.0, 2865000.0, 2876000.0, 2886000.0, 2897000.0, 2908000.0, - 2918000.0, 2939000.0, 2960000.0, 2981000.0, 3002000.0, 3022000.0, 3043000.0, 3064000.0, 3085000.0, 3105000.0, 3126000.0, 3147000.0, - 3168000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, 2791000.0, 2795000.0, - 2800000.0, 2804000.0, 2809000.0, 2820000.0, 2831000.0, 2842000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2896000.0, 2906000.0, - 2917000.0, 2938000.0, 2959000.0, 2980000.0, 3001000.0, 3022000.0, 3042000.0, 3063000.0, 3084000.0, 3105000.0, 3125000.0, 3146000.0, - 3167000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2789000.0, 2793000.0, - 2798000.0, 2802000.0, 2807000.0, 2818000.0, 2829000.0, 2840000.0, 2851000.0, 2862000.0, 2873000.0, 2884000.0, 2894000.0, 2905000.0, - 2916000.0, 2937000.0, 2958000.0, 2979000.0, 3000000.0, 3021000.0, 3042000.0, 3062000.0, 3083000.0, 3104000.0, 3125000.0, 3146000.0, - 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2757000.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2782000.0, 2786000.0, 2791000.0, - 2796000.0, 2800000.0, 2805000.0, 2816000.0, 2827000.0, 2839000.0, 2850000.0, 2861000.0, 2872000.0, 2882000.0, 2893000.0, 2904000.0, - 2915000.0, 2936000.0, 2957000.0, 2978000.0, 2999000.0, 3020000.0, 3041000.0, 3062000.0, 3082000.0, 3103000.0, 3124000.0, 3145000.0, - 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3376000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2789000.0, - 2793000.0, 2798000.0, 2803000.0, 2814000.0, 2826000.0, 2837000.0, 2848000.0, 2859000.0, 2870000.0, 2881000.0, 2892000.0, 2902000.0, - 2913000.0, 2935000.0, 2956000.0, 2977000.0, 2998000.0, 3019000.0, 3040000.0, 3061000.0, 3082000.0, 3102000.0, 3123000.0, 3144000.0, - 3165000.0, 3186000.0, 3207000.0, 3280000.0, 3376000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, - 2791000.0, 2796000.0, 2800000.0, 2812000.0, 2824000.0, 2835000.0, 2846000.0, 2857000.0, 2868000.0, 2879000.0, 2890000.0, 2901000.0, - 2912000.0, 2933000.0, 2955000.0, 2976000.0, 2997000.0, 3018000.0, 3039000.0, 3060000.0, 3081000.0, 3102000.0, 3123000.0, 3144000.0, - 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2764000.0, 2769000.0, 2774000.0, 2779000.0, 2784000.0, - 2789000.0, 2793000.0, 2798000.0, 2810000.0, 2821000.0, 2833000.0, 2844000.0, 2855000.0, 2867000.0, 2878000.0, 2889000.0, 2900000.0, - 2910000.0, 2932000.0, 2953000.0, 2975000.0, 2996000.0, 3017000.0, 3038000.0, 3059000.0, 3080000.0, 3101000.0, 3122000.0, 3143000.0, - 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3482000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2766000.0, 2771000.0, 2776000.0, 2781000.0, - 2786000.0, 2791000.0, 2796000.0, 2808000.0, 2819000.0, 2831000.0, 2842000.0, 2854000.0, 2865000.0, 2876000.0, 2887000.0, 2898000.0, - 2909000.0, 2931000.0, 2952000.0, 2973000.0, 2995000.0, 3016000.0, 3037000.0, 3058000.0, 3079000.0, 3100000.0, 3121000.0, 3142000.0, - 3163000.0, 3184000.0, 3205000.0, 3280000.0, 3374000.0, 3482000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2768000.0, 2773000.0, 2778000.0, - 2783000.0, 2788000.0, 2793000.0, 2805000.0, 2817000.0, 2829000.0, 2840000.0, 2852000.0, 2863000.0, 2874000.0, 2885000.0, 2896000.0, - 2907000.0, 2929000.0, 2951000.0, 2972000.0, 2994000.0, 3015000.0, 3036000.0, 3057000.0, 3078000.0, 3099000.0, 3120000.0, 3141000.0, - 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3374000.0, 3481000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2770000.0, 2775000.0, - 2780000.0, 2785000.0, 2790000.0, 2802000.0, 2814000.0, 2826000.0, 2838000.0, 2850000.0, 2861000.0, 2872000.0, 2883000.0, 2895000.0, - 2906000.0, 2928000.0, 2949000.0, 2971000.0, 2992000.0, 3014000.0, 3035000.0, 3056000.0, 3077000.0, 3098000.0, 3119000.0, 3140000.0, - 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3373000.0, 3481000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2772000.0, - 2777000.0, 2782000.0, 2787000.0, 2800000.0, 2812000.0, 2824000.0, 2836000.0, 2847000.0, 2859000.0, 2870000.0, 2882000.0, 2893000.0, - 2904000.0, 2926000.0, 2948000.0, 2969000.0, 2991000.0, 3012000.0, 3034000.0, 3055000.0, 3076000.0, 3097000.0, 3118000.0, 3140000.0, - 3161000.0, 3182000.0, 3203000.0, 3280000.0, 3373000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2774000.0, 2779000.0, 2784000.0, 2797000.0, 2809000.0, 2821000.0, 2833000.0, 2845000.0, 2857000.0, 2868000.0, 2880000.0, 2891000.0, - 2902000.0, 2924000.0, 2946000.0, 2968000.0, 2990000.0, 3011000.0, 3033000.0, 3054000.0, 3075000.0, 3096000.0, 3118000.0, 3139000.0, - 3160000.0, 3181000.0, 3202000.0, 3280000.0, 3372000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2775000.0, 2781000.0, 2794000.0, 2806000.0, 2819000.0, 2831000.0, 2843000.0, 2854000.0, 2866000.0, 2878000.0, 2889000.0, - 2900000.0, 2923000.0, 2945000.0, 2967000.0, 2988000.0, 3010000.0, 3031000.0, 3053000.0, 3074000.0, 3095000.0, 3117000.0, 3138000.0, - 3159000.0, 3180000.0, 3201000.0, 3280000.0, 3372000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2777000.0, 2790000.0, 2803000.0, 2816000.0, 2828000.0, 2840000.0, 2852000.0, 2864000.0, 2875000.0, 2887000.0, - 2898000.0, 2921000.0, 2943000.0, 2965000.0, 2987000.0, 3009000.0, 3030000.0, 3052000.0, 3073000.0, 3094000.0, 3116000.0, 3137000.0, - 3158000.0, 3179000.0, 3201000.0, 3280000.0, 3371000.0, 3479000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2781000.0, 2795000.0, 2808000.0, 2821000.0, 2833000.0, 2846000.0, 2858000.0, 2870000.0, 2881000.0, - 2893000.0, 2916000.0, 2939000.0, 2961000.0, 2983000.0, 3005000.0, 3027000.0, 3048000.0, 3070000.0, 3091000.0, 3113000.0, 3134000.0, - 3156000.0, 3177000.0, 3198000.0, 3280000.0, 3370000.0, 3478000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2785000.0, 2799000.0, 2813000.0, 2826000.0, 2838000.0, 2851000.0, 2863000.0, 2875000.0, - 2887000.0, 2910000.0, 2933000.0, 2956000.0, 2979000.0, 3001000.0, 3023000.0, 3045000.0, 3067000.0, 3088000.0, 3110000.0, 3132000.0, - 3153000.0, 3175000.0, 3196000.0, 3280000.0, 3368000.0, 3476000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2789000.0, 2803000.0, 2817000.0, 2830000.0, 2843000.0, 2856000.0, 2868000.0, - 2880000.0, 2904000.0, 2928000.0, 2951000.0, 2974000.0, 2996000.0, 3019000.0, 3041000.0, 3063000.0, 3085000.0, 3107000.0, 3128000.0, - 3150000.0, 3172000.0, 3193000.0, 3280000.0, 3366000.0, 3475000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2792000.0, 2807000.0, 2821000.0, 2834000.0, 2847000.0, 2860000.0, - 2873000.0, 2898000.0, 2922000.0, 2945000.0, 2969000.0, 2992000.0, 3014000.0, 3037000.0, 3059000.0, 3081000.0, 3103000.0, 3125000.0, - 3147000.0, 3169000.0, 3190000.0, 3280000.0, 3364000.0, 3473000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2795000.0, 2810000.0, 2824000.0, 2838000.0, 2851000.0, - 2864000.0, 2890000.0, 2915000.0, 2939000.0, 2963000.0, 2986000.0, 3009000.0, 3032000.0, 3055000.0, 3077000.0, 3099000.0, 3121000.0, - 3143000.0, 3165000.0, 3187000.0, 3280000.0, 3362000.0, 3471000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2797000.0, 2813000.0, 2827000.0, 2841000.0, - 2855000.0, 2882000.0, 2907000.0, 2932000.0, 2956000.0, 2980000.0, 3004000.0, 3027000.0, 3050000.0, 3072000.0, 3095000.0, 3117000.0, - 3140000.0, 3162000.0, 3184000.0, 3280000.0, 3359000.0, 3469000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2799000.0, 2815000.0, 2830000.0, - 2844000.0, 2872000.0, 2899000.0, 2924000.0, 2949000.0, 2974000.0, 2998000.0, 3021000.0, 3044000.0, 3067000.0, 3090000.0, 3113000.0, - 3135000.0, 3158000.0, 3180000.0, 3280000.0, 3357000.0, 3467000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2801000.0, 2817000.0, - 2832000.0, 2862000.0, 2889000.0, 2916000.0, 2941000.0, 2966000.0, 2991000.0, 3015000.0, 3039000.0, 3062000.0, 3085000.0, 3108000.0, - 3131000.0, 3154000.0, 3176000.0, 3280000.0, 3354000.0, 3465000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2802000.0, - 2819000.0, 2850000.0, 2879000.0, 2906000.0, 2933000.0, 2958000.0, 2984000.0, 3008000.0, 3032000.0, 3056000.0, 3080000.0, 3103000.0, - 3126000.0, 3149000.0, 3172000.0, 3280000.0, 3351000.0, 3462000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2803000.0, 2836000.0, 2867000.0, 2895000.0, 2923000.0, 2950000.0, 2975000.0, 3001000.0, 3025000.0, 3050000.0, 3073000.0, 3097000.0, - 3121000.0, 3144000.0, 3167000.0, 3280000.0, 3348000.0, 3459000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2803000.0, 2838000.0, 2870000.0, 2900000.0, 2929000.0, 2957000.0, 2983000.0, 3009000.0, 3035000.0, 3060000.0, 3084000.0, - 3108000.0, 3132000.0, 3156000.0, 3280000.0, 3340000.0, 3453000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2801000.0, 2838000.0, 2872000.0, 2904000.0, 2934000.0, 2963000.0, 2990000.0, 3017000.0, 3043000.0, 3069000.0, - 3094000.0, 3119000.0, 3143000.0, 3280000.0, 3332000.0, 3446000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2797000.0, 2837000.0, 2873000.0, 2906000.0, 2937000.0, 2967000.0, 2996000.0, 3023000.0, 3050000.0, - 3077000.0, 3103000.0, 3128000.0, 3280000.0, 3322000.0, 3438000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2790000.0, 2833000.0, 2871000.0, 2906000.0, 2939000.0, 2970000.0, 3000000.0, 3029000.0, - 3057000.0, 3084000.0, 3110000.0, 3280000.0, 3310000.0, 3429000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2780000.0, 2826000.0, 2867000.0, 2905000.0, 2939000.0, 2972000.0, 3003000.0, - 3033000.0, 3062000.0, 3090000.0, 3280000.0, 3297000.0, 3418000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2767000.0, 2817000.0, - 2861000.0, 2901000.0, 2938000.0, 2972000.0, 3004000.0, 3036000.0, 3066000.0, 3280000.0, 3282000.0, 3406000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2750000.0, - 2806000.0, 2853000.0, 2895000.0, 2934000.0, 2970000.0, 3004000.0, 3037000.0, 3280000.0, 3264000.0, 3392000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2728000.0, - 2790000.0, 2842000.0, 2887000.0, 2929000.0, 2967000.0, 3003000.0, 3280000.0, 3244000.0, 3377000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2701000.0, 2771000.0, 2828000.0, 2877000.0, 2921000.0, 2961000.0, 3280000.0, 3222000.0, 3359000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2666000.0, 2747000.0, 2810000.0, 2864000.0, 2911000.0, 3280000.0, 3195000.0, 3339000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2622000.0, 2718000.0, 2789000.0, 2847000.0, 3280000.0, 3165000.0, 3316000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2564000.0, 2683000.0, 2763000.0, 3280000.0, 3130000.0, 3290000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2481000.0, 2641000.0, 3280000.0, 3089000.0, 3260000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2335000.0, 3280000.0, 3040000.0, 3226000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2821000.0, 3085000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2671000.0, 2998000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2512000.0, 2906000.0}, - }}; - - [[maybe_unused]] static constexpr std::array, DefaultNumSteamSuperheatedPressure> - DefaultSteamSuperheatedDensityDataTable = {{ - {4.855e-03, 4.837e-03, 4.767e-03, 4.683e-03, 4.601e-03, 4.522e-03, 4.446e-03, 4.373e-03, 4.302e-03, 4.233e-03, 4.167e-03, 4.102e-03, - 4.039e-03, 3.979e-03, 3.920e-03, 3.863e-03, 3.840e-03, 3.818e-03, 3.796e-03, 3.775e-03, 3.753e-03, 3.732e-03, 3.711e-03, 3.691e-03, - 3.670e-03, 3.650e-03, 3.630e-03, 3.610e-03, 3.591e-03, 3.571e-03, 3.562e-03, 3.552e-03, 3.543e-03, 3.533e-03, 3.524e-03, 3.514e-03, - 3.505e-03, 3.496e-03, 3.487e-03, 3.477e-03, 3.468e-03, 3.459e-03, 3.450e-03, 3.441e-03, 3.432e-03, 3.424e-03, 3.415e-03, 3.406e-03, - 3.397e-03, 3.388e-03, 3.380e-03, 3.371e-03, 3.363e-03, 3.354e-03, 3.346e-03, 3.337e-03, 3.329e-03, 3.321e-03, 3.312e-03, 3.304e-03, - 3.296e-03, 3.288e-03, 3.271e-03, 3.255e-03, 3.239e-03, 3.224e-03, 3.208e-03, 3.193e-03, 3.177e-03, 3.162e-03, 3.147e-03, 3.132e-03, - 3.117e-03, 3.103e-03, 3.088e-03, 3.074e-03, 3.060e-03, 3.046e-03, 3.032e-03, 3.018e-03, 3.004e-03, 2.991e-03, 2.977e-03, 2.964e-03, - 2.951e-03, 2.938e-03, 2.925e-03, 2.893e-03, 2.862e-03, 2.831e-03, 2.801e-03, 2.772e-03, 2.743e-03, 2.715e-03, 2.688e-03, 2.661e-03, - 2.634e-03, 2.583e-03, 2.533e-03, 2.486e-03, 2.440e-03, 2.396e-03, 2.353e-03, 2.312e-03, 2.273e-03, 2.234e-03, 2.197e-03, 2.162e-03, - 2.127e-03, 2.093e-03, 2.061e-03, 3.542e-05, 1.833e-03, 1.714e-03}, - {0.0, 5.196e-03, 5.121e-03, 5.031e-03, 4.943e-03, 4.859e-03, 4.777e-03, 4.698e-03, 4.622e-03, 4.548e-03, 4.476e-03, 4.407e-03, - 4.340e-03, 4.274e-03, 4.211e-03, 4.150e-03, 4.126e-03, 4.102e-03, 4.078e-03, 4.055e-03, 4.032e-03, 4.009e-03, 3.987e-03, 3.965e-03, - 3.943e-03, 3.921e-03, 3.899e-03, 3.878e-03, 3.857e-03, 3.836e-03, 3.826e-03, 3.816e-03, 3.806e-03, 3.795e-03, 3.785e-03, 3.775e-03, - 3.765e-03, 3.755e-03, 3.746e-03, 3.736e-03, 3.726e-03, 3.716e-03, 3.707e-03, 3.697e-03, 3.687e-03, 3.678e-03, 3.668e-03, 3.659e-03, - 3.650e-03, 3.640e-03, 3.631e-03, 3.622e-03, 3.612e-03, 3.603e-03, 3.594e-03, 3.585e-03, 3.576e-03, 3.567e-03, 3.558e-03, 3.549e-03, - 3.541e-03, 3.532e-03, 3.514e-03, 3.497e-03, 3.480e-03, 3.463e-03, 3.446e-03, 3.430e-03, 3.413e-03, 3.397e-03, 3.381e-03, 3.365e-03, - 3.349e-03, 3.333e-03, 3.318e-03, 3.302e-03, 3.287e-03, 3.272e-03, 3.257e-03, 3.242e-03, 3.228e-03, 3.213e-03, 3.198e-03, 3.184e-03, - 3.170e-03, 3.156e-03, 3.142e-03, 3.108e-03, 3.074e-03, 3.041e-03, 3.009e-03, 2.978e-03, 2.947e-03, 2.917e-03, 2.887e-03, 2.858e-03, - 2.830e-03, 2.775e-03, 2.722e-03, 2.671e-03, 2.621e-03, 2.574e-03, 2.528e-03, 2.484e-03, 2.442e-03, 2.400e-03, 2.361e-03, 2.322e-03, - 2.285e-03, 2.249e-03, 2.214e-03, 3.542e-05, 1.969e-03, 1.841e-03}, - {0.0, 0.0, 6.802e-03, 6.681e-03, 6.565e-03, 6.453e-03, 6.344e-03, 6.239e-03, 6.138e-03, 6.040e-03, 5.944e-03, 5.852e-03, - 5.763e-03, 5.676e-03, 5.592e-03, 5.511e-03, 5.479e-03, 5.447e-03, 5.416e-03, 5.385e-03, 5.355e-03, 5.324e-03, 5.295e-03, 5.265e-03, - 5.236e-03, 5.207e-03, 5.178e-03, 5.150e-03, 5.122e-03, 5.095e-03, 5.081e-03, 5.067e-03, 5.054e-03, 5.040e-03, 5.027e-03, 5.014e-03, - 5.000e-03, 4.987e-03, 4.974e-03, 4.961e-03, 4.948e-03, 4.935e-03, 4.922e-03, 4.909e-03, 4.897e-03, 4.884e-03, 4.871e-03, 4.859e-03, - 4.846e-03, 4.834e-03, 4.822e-03, 4.809e-03, 4.797e-03, 4.785e-03, 4.773e-03, 4.761e-03, 4.749e-03, 4.737e-03, 4.725e-03, 4.714e-03, - 4.702e-03, 4.690e-03, 4.667e-03, 4.644e-03, 4.621e-03, 4.599e-03, 4.577e-03, 4.555e-03, 4.533e-03, 4.511e-03, 4.490e-03, 4.468e-03, - 4.447e-03, 4.427e-03, 4.406e-03, 4.385e-03, 4.365e-03, 4.345e-03, 4.325e-03, 4.306e-03, 4.286e-03, 4.267e-03, 4.247e-03, 4.228e-03, - 4.210e-03, 4.191e-03, 4.172e-03, 4.127e-03, 4.082e-03, 4.039e-03, 3.996e-03, 3.954e-03, 3.913e-03, 3.873e-03, 3.834e-03, 3.796e-03, - 3.758e-03, 3.685e-03, 3.614e-03, 3.546e-03, 3.481e-03, 3.418e-03, 3.357e-03, 3.299e-03, 3.242e-03, 3.188e-03, 3.135e-03, 3.084e-03, - 3.034e-03, 2.986e-03, 2.940e-03, 3.542e-05, 2.615e-03, 2.445e-03}, - {0.0, 0.0, 0.0, 9.407e-03, 9.243e-03, 9.084e-03, 8.931e-03, 8.783e-03, 8.640e-03, 8.502e-03, 8.368e-03, 8.238e-03, - 8.113e-03, 7.991e-03, 7.872e-03, 7.757e-03, 7.712e-03, 7.668e-03, 7.624e-03, 7.580e-03, 7.537e-03, 7.495e-03, 7.453e-03, 7.411e-03, - 7.370e-03, 7.330e-03, 7.289e-03, 7.250e-03, 7.210e-03, 7.172e-03, 7.152e-03, 7.133e-03, 7.114e-03, 7.095e-03, 7.076e-03, 7.057e-03, - 7.039e-03, 7.020e-03, 7.002e-03, 6.983e-03, 6.965e-03, 6.947e-03, 6.929e-03, 6.911e-03, 6.893e-03, 6.875e-03, 6.857e-03, 6.840e-03, - 6.822e-03, 6.805e-03, 6.787e-03, 6.770e-03, 6.753e-03, 6.736e-03, 6.719e-03, 6.702e-03, 6.685e-03, 6.668e-03, 6.651e-03, 6.635e-03, - 6.618e-03, 6.602e-03, 6.569e-03, 6.537e-03, 6.505e-03, 6.473e-03, 6.442e-03, 6.411e-03, 6.380e-03, 6.350e-03, 6.320e-03, 6.290e-03, - 6.260e-03, 6.231e-03, 6.202e-03, 6.173e-03, 6.144e-03, 6.116e-03, 6.088e-03, 6.060e-03, 6.033e-03, 6.006e-03, 5.979e-03, 5.952e-03, - 5.925e-03, 5.899e-03, 5.873e-03, 5.809e-03, 5.746e-03, 5.685e-03, 5.625e-03, 5.566e-03, 5.508e-03, 5.452e-03, 5.397e-03, 5.342e-03, - 5.289e-03, 5.186e-03, 5.087e-03, 4.992e-03, 4.900e-03, 4.811e-03, 4.726e-03, 4.643e-03, 4.564e-03, 4.487e-03, 4.412e-03, 4.340e-03, - 4.271e-03, 4.203e-03, 4.138e-03, 3.542e-05, 3.680e-03, 3.442e-03}, - {0.0, 0.0, 0.0, 0.0, 1.284e-02, 1.262e-02, 1.241e-02, 1.220e-02, 1.200e-02, 1.181e-02, 1.162e-02, 1.144e-02, - 1.127e-02, 1.110e-02, 1.093e-02, 1.078e-02, 1.071e-02, 1.065e-02, 1.059e-02, 1.053e-02, 1.047e-02, 1.041e-02, 1.035e-02, 1.029e-02, - 1.024e-02, 1.018e-02, 1.012e-02, 1.007e-02, 1.001e-02, 9.961e-03, 9.934e-03, 9.907e-03, 9.881e-03, 9.855e-03, 9.828e-03, 9.802e-03, - 9.776e-03, 9.750e-03, 9.725e-03, 9.699e-03, 9.674e-03, 9.649e-03, 9.623e-03, 9.598e-03, 9.574e-03, 9.549e-03, 9.524e-03, 9.500e-03, - 9.475e-03, 9.451e-03, 9.427e-03, 9.403e-03, 9.379e-03, 9.355e-03, 9.332e-03, 9.308e-03, 9.285e-03, 9.261e-03, 9.238e-03, 9.215e-03, - 9.192e-03, 9.170e-03, 9.124e-03, 9.079e-03, 9.035e-03, 8.991e-03, 8.947e-03, 8.904e-03, 8.862e-03, 8.819e-03, 8.777e-03, 8.736e-03, - 8.695e-03, 8.654e-03, 8.614e-03, 8.574e-03, 8.534e-03, 8.495e-03, 8.456e-03, 8.417e-03, 8.379e-03, 8.341e-03, 8.304e-03, 8.267e-03, - 8.230e-03, 8.193e-03, 8.157e-03, 8.068e-03, 7.981e-03, 7.896e-03, 7.812e-03, 7.731e-03, 7.651e-03, 7.572e-03, 7.495e-03, 7.420e-03, - 7.346e-03, 7.203e-03, 7.065e-03, 6.933e-03, 6.805e-03, 6.682e-03, 6.563e-03, 6.449e-03, 6.338e-03, 6.231e-03, 6.128e-03, 6.028e-03, - 5.931e-03, 5.838e-03, 5.747e-03, 3.542e-05, 5.111e-03, 4.781e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 1.731e-02, 1.702e-02, 1.674e-02, 1.646e-02, 1.620e-02, 1.594e-02, 1.570e-02, - 1.546e-02, 1.522e-02, 1.500e-02, 1.478e-02, 1.469e-02, 1.461e-02, 1.452e-02, 1.444e-02, 1.436e-02, 1.428e-02, 1.420e-02, 1.412e-02, - 1.404e-02, 1.396e-02, 1.389e-02, 1.381e-02, 1.374e-02, 1.366e-02, 1.362e-02, 1.359e-02, 1.355e-02, 1.352e-02, 1.348e-02, 1.344e-02, - 1.341e-02, 1.337e-02, 1.334e-02, 1.330e-02, 1.327e-02, 1.323e-02, 1.320e-02, 1.316e-02, 1.313e-02, 1.310e-02, 1.306e-02, 1.303e-02, - 1.300e-02, 1.296e-02, 1.293e-02, 1.290e-02, 1.286e-02, 1.283e-02, 1.280e-02, 1.277e-02, 1.273e-02, 1.270e-02, 1.267e-02, 1.264e-02, - 1.261e-02, 1.258e-02, 1.251e-02, 1.245e-02, 1.239e-02, 1.233e-02, 1.227e-02, 1.221e-02, 1.215e-02, 1.210e-02, 1.204e-02, 1.198e-02, - 1.192e-02, 1.187e-02, 1.181e-02, 1.176e-02, 1.170e-02, 1.165e-02, 1.160e-02, 1.154e-02, 1.149e-02, 1.144e-02, 1.139e-02, 1.134e-02, - 1.129e-02, 1.124e-02, 1.119e-02, 1.107e-02, 1.095e-02, 1.083e-02, 1.071e-02, 1.060e-02, 1.049e-02, 1.038e-02, 1.028e-02, 1.018e-02, - 1.007e-02, 9.879e-03, 9.690e-03, 9.508e-03, 9.333e-03, 9.164e-03, 9.001e-03, 8.844e-03, 8.692e-03, 8.546e-03, 8.404e-03, 8.267e-03, - 8.134e-03, 8.006e-03, 7.881e-03, 3.542e-05, 7.009e-03, 6.556e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.307e-02, 2.269e-02, 2.232e-02, 2.196e-02, 2.161e-02, 2.128e-02, - 2.095e-02, 2.063e-02, 2.033e-02, 2.003e-02, 1.991e-02, 1.980e-02, 1.968e-02, 1.957e-02, 1.946e-02, 1.935e-02, 1.924e-02, 1.913e-02, - 1.903e-02, 1.892e-02, 1.882e-02, 1.872e-02, 1.862e-02, 1.851e-02, 1.846e-02, 1.842e-02, 1.837e-02, 1.832e-02, 1.827e-02, 1.822e-02, - 1.817e-02, 1.812e-02, 1.808e-02, 1.803e-02, 1.798e-02, 1.793e-02, 1.789e-02, 1.784e-02, 1.779e-02, 1.775e-02, 1.770e-02, 1.766e-02, - 1.761e-02, 1.757e-02, 1.752e-02, 1.748e-02, 1.743e-02, 1.739e-02, 1.734e-02, 1.730e-02, 1.726e-02, 1.721e-02, 1.717e-02, 1.713e-02, - 1.708e-02, 1.704e-02, 1.696e-02, 1.687e-02, 1.679e-02, 1.671e-02, 1.663e-02, 1.655e-02, 1.647e-02, 1.639e-02, 1.631e-02, 1.624e-02, - 1.616e-02, 1.608e-02, 1.601e-02, 1.593e-02, 1.586e-02, 1.579e-02, 1.572e-02, 1.564e-02, 1.557e-02, 1.550e-02, 1.543e-02, 1.536e-02, - 1.530e-02, 1.523e-02, 1.516e-02, 1.499e-02, 1.483e-02, 1.467e-02, 1.452e-02, 1.437e-02, 1.422e-02, 1.407e-02, 1.393e-02, 1.379e-02, - 1.365e-02, 1.339e-02, 1.313e-02, 1.288e-02, 1.265e-02, 1.242e-02, 1.220e-02, 1.198e-02, 1.178e-02, 1.158e-02, 1.139e-02, 1.120e-02, - 1.102e-02, 1.085e-02, 1.068e-02, 3.542e-05, 9.498e-03, 8.884e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.042e-02, 2.992e-02, 2.943e-02, 2.897e-02, 2.851e-02, - 2.808e-02, 2.765e-02, 2.724e-02, 2.684e-02, 2.669e-02, 2.653e-02, 2.638e-02, 2.623e-02, 2.608e-02, 2.593e-02, 2.579e-02, 2.564e-02, - 2.550e-02, 2.536e-02, 2.522e-02, 2.508e-02, 2.494e-02, 2.481e-02, 2.474e-02, 2.468e-02, 2.461e-02, 2.454e-02, 2.448e-02, 2.441e-02, - 2.435e-02, 2.428e-02, 2.422e-02, 2.416e-02, 2.409e-02, 2.403e-02, 2.397e-02, 2.391e-02, 2.384e-02, 2.378e-02, 2.372e-02, 2.366e-02, - 2.360e-02, 2.354e-02, 2.348e-02, 2.342e-02, 2.336e-02, 2.330e-02, 2.324e-02, 2.318e-02, 2.312e-02, 2.306e-02, 2.301e-02, 2.295e-02, - 2.289e-02, 2.284e-02, 2.272e-02, 2.261e-02, 2.250e-02, 2.239e-02, 2.228e-02, 2.217e-02, 2.207e-02, 2.196e-02, 2.186e-02, 2.175e-02, - 2.165e-02, 2.155e-02, 2.145e-02, 2.135e-02, 2.125e-02, 2.115e-02, 2.106e-02, 2.096e-02, 2.087e-02, 2.077e-02, 2.068e-02, 2.059e-02, - 2.049e-02, 2.040e-02, 2.031e-02, 2.009e-02, 1.987e-02, 1.966e-02, 1.945e-02, 1.925e-02, 1.905e-02, 1.885e-02, 1.866e-02, 1.848e-02, - 1.829e-02, 1.794e-02, 1.759e-02, 1.726e-02, 1.694e-02, 1.664e-02, 1.634e-02, 1.606e-02, 1.578e-02, 1.552e-02, 1.526e-02, 1.501e-02, - 1.477e-02, 1.453e-02, 1.431e-02, 3.542e-05, 1.273e-02, 1.190e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.967e-02, 3.903e-02, 3.841e-02, 3.781e-02, - 3.723e-02, 3.666e-02, 3.612e-02, 3.559e-02, 3.538e-02, 3.518e-02, 3.497e-02, 3.477e-02, 3.457e-02, 3.438e-02, 3.419e-02, 3.399e-02, - 3.380e-02, 3.362e-02, 3.343e-02, 3.325e-02, 3.307e-02, 3.289e-02, 3.280e-02, 3.271e-02, 3.262e-02, 3.254e-02, 3.245e-02, 3.236e-02, - 3.228e-02, 3.219e-02, 3.211e-02, 3.202e-02, 3.194e-02, 3.186e-02, 3.177e-02, 3.169e-02, 3.161e-02, 3.153e-02, 3.144e-02, 3.136e-02, - 3.128e-02, 3.120e-02, 3.112e-02, 3.104e-02, 3.096e-02, 3.089e-02, 3.081e-02, 3.073e-02, 3.065e-02, 3.058e-02, 3.050e-02, 3.042e-02, - 3.035e-02, 3.027e-02, 3.012e-02, 2.997e-02, 2.983e-02, 2.968e-02, 2.954e-02, 2.939e-02, 2.925e-02, 2.911e-02, 2.897e-02, 2.884e-02, - 2.870e-02, 2.857e-02, 2.843e-02, 2.830e-02, 2.817e-02, 2.804e-02, 2.791e-02, 2.778e-02, 2.766e-02, 2.753e-02, 2.741e-02, 2.729e-02, - 2.716e-02, 2.704e-02, 2.692e-02, 2.663e-02, 2.634e-02, 2.606e-02, 2.579e-02, 2.552e-02, 2.525e-02, 2.499e-02, 2.474e-02, 2.449e-02, - 2.425e-02, 2.377e-02, 2.332e-02, 2.288e-02, 2.246e-02, 2.205e-02, 2.166e-02, 2.128e-02, 2.092e-02, 2.057e-02, 2.022e-02, 1.989e-02, - 1.957e-02, 1.927e-02, 1.897e-02, 3.542e-05, 1.687e-02, 1.578e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.124e-02, 5.042e-02, 4.963e-02, - 4.887e-02, 4.812e-02, 4.741e-02, 4.671e-02, 4.644e-02, 4.617e-02, 4.590e-02, 4.564e-02, 4.537e-02, 4.512e-02, 4.486e-02, 4.461e-02, - 4.436e-02, 4.412e-02, 4.387e-02, 4.363e-02, 4.340e-02, 4.316e-02, 4.304e-02, 4.293e-02, 4.281e-02, 4.270e-02, 4.258e-02, 4.247e-02, - 4.236e-02, 4.225e-02, 4.213e-02, 4.202e-02, 4.191e-02, 4.180e-02, 4.169e-02, 4.158e-02, 4.148e-02, 4.137e-02, 4.126e-02, 4.116e-02, - 4.105e-02, 4.094e-02, 4.084e-02, 4.073e-02, 4.063e-02, 4.053e-02, 4.043e-02, 4.032e-02, 4.022e-02, 4.012e-02, 4.002e-02, 3.992e-02, - 3.982e-02, 3.972e-02, 3.952e-02, 3.933e-02, 3.914e-02, 3.895e-02, 3.876e-02, 3.857e-02, 3.838e-02, 3.820e-02, 3.802e-02, 3.784e-02, - 3.766e-02, 3.748e-02, 3.731e-02, 3.713e-02, 3.696e-02, 3.679e-02, 3.662e-02, 3.646e-02, 3.629e-02, 3.613e-02, 3.596e-02, 3.580e-02, - 3.564e-02, 3.548e-02, 3.533e-02, 3.494e-02, 3.456e-02, 3.419e-02, 3.383e-02, 3.348e-02, 3.313e-02, 3.279e-02, 3.246e-02, 3.213e-02, - 3.181e-02, 3.119e-02, 3.059e-02, 3.002e-02, 2.947e-02, 2.893e-02, 2.842e-02, 2.792e-02, 2.744e-02, 2.698e-02, 2.653e-02, 2.610e-02, - 2.568e-02, 2.528e-02, 2.488e-02, 3.542e-05, 2.213e-02, 2.070e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.556e-02, 6.453e-02, - 6.353e-02, 6.256e-02, 6.163e-02, 6.072e-02, 6.036e-02, 6.001e-02, 5.966e-02, 5.932e-02, 5.898e-02, 5.864e-02, 5.831e-02, 5.799e-02, - 5.766e-02, 5.734e-02, 5.702e-02, 5.671e-02, 5.640e-02, 5.610e-02, 5.594e-02, 5.579e-02, 5.564e-02, 5.549e-02, 5.535e-02, 5.520e-02, - 5.505e-02, 5.490e-02, 5.476e-02, 5.461e-02, 5.447e-02, 5.433e-02, 5.419e-02, 5.404e-02, 5.390e-02, 5.376e-02, 5.362e-02, 5.349e-02, - 5.335e-02, 5.321e-02, 5.307e-02, 5.294e-02, 5.280e-02, 5.267e-02, 5.254e-02, 5.240e-02, 5.227e-02, 5.214e-02, 5.201e-02, 5.188e-02, - 5.175e-02, 5.162e-02, 5.136e-02, 5.111e-02, 5.086e-02, 5.061e-02, 5.036e-02, 5.012e-02, 4.988e-02, 4.964e-02, 4.940e-02, 4.917e-02, - 4.894e-02, 4.871e-02, 4.848e-02, 4.825e-02, 4.803e-02, 4.781e-02, 4.759e-02, 4.737e-02, 4.716e-02, 4.694e-02, 4.673e-02, 4.652e-02, - 4.632e-02, 4.611e-02, 4.591e-02, 4.540e-02, 4.491e-02, 4.443e-02, 4.396e-02, 4.350e-02, 4.305e-02, 4.261e-02, 4.218e-02, 4.175e-02, - 4.134e-02, 4.053e-02, 3.975e-02, 3.901e-02, 3.829e-02, 3.759e-02, 3.693e-02, 3.628e-02, 3.566e-02, 3.506e-02, 3.448e-02, 3.391e-02, - 3.337e-02, 3.284e-02, 3.233e-02, 3.542e-05, 2.875e-02, 2.689e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.315e-02, - 8.185e-02, 8.060e-02, 7.939e-02, 7.821e-02, 7.775e-02, 7.730e-02, 7.685e-02, 7.641e-02, 7.597e-02, 7.553e-02, 7.511e-02, 7.468e-02, - 7.426e-02, 7.385e-02, 7.344e-02, 7.304e-02, 7.264e-02, 7.224e-02, 7.205e-02, 7.185e-02, 7.166e-02, 7.147e-02, 7.128e-02, 7.108e-02, - 7.090e-02, 7.071e-02, 7.052e-02, 7.033e-02, 7.015e-02, 6.996e-02, 6.978e-02, 6.960e-02, 6.942e-02, 6.923e-02, 6.906e-02, 6.888e-02, - 6.870e-02, 6.852e-02, 6.835e-02, 6.817e-02, 6.800e-02, 6.782e-02, 6.765e-02, 6.748e-02, 6.731e-02, 6.714e-02, 6.697e-02, 6.680e-02, - 6.664e-02, 6.647e-02, 6.614e-02, 6.581e-02, 6.549e-02, 6.517e-02, 6.485e-02, 6.454e-02, 6.423e-02, 6.392e-02, 6.361e-02, 6.331e-02, - 6.301e-02, 6.272e-02, 6.242e-02, 6.213e-02, 6.185e-02, 6.156e-02, 6.128e-02, 6.100e-02, 6.072e-02, 6.044e-02, 6.017e-02, 5.990e-02, - 5.963e-02, 5.937e-02, 5.911e-02, 5.846e-02, 5.783e-02, 5.721e-02, 5.660e-02, 5.601e-02, 5.543e-02, 5.486e-02, 5.430e-02, 5.375e-02, - 5.322e-02, 5.218e-02, 5.118e-02, 5.022e-02, 4.929e-02, 4.840e-02, 4.754e-02, 4.671e-02, 4.591e-02, 4.513e-02, 4.438e-02, 4.366e-02, - 4.296e-02, 4.228e-02, 4.162e-02, 3.542e-05, 3.701e-02, 3.462e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.10460, 0.10290, 0.10140, 9.988e-02, 9.929e-02, 9.871e-02, 9.813e-02, 9.757e-02, 9.700e-02, 9.645e-02, 9.590e-02, 9.536e-02, - 9.482e-02, 9.430e-02, 9.377e-02, 9.325e-02, 9.274e-02, 9.224e-02, 9.199e-02, 9.174e-02, 9.149e-02, 9.124e-02, 9.100e-02, 9.075e-02, - 9.051e-02, 9.027e-02, 9.003e-02, 8.979e-02, 8.955e-02, 8.932e-02, 8.908e-02, 8.885e-02, 8.862e-02, 8.839e-02, 8.816e-02, 8.793e-02, - 8.770e-02, 8.747e-02, 8.725e-02, 8.703e-02, 8.680e-02, 8.658e-02, 8.636e-02, 8.614e-02, 8.592e-02, 8.571e-02, 8.549e-02, 8.528e-02, - 8.506e-02, 8.485e-02, 8.443e-02, 8.401e-02, 8.360e-02, 8.319e-02, 8.278e-02, 8.238e-02, 8.198e-02, 8.159e-02, 8.120e-02, 8.081e-02, - 8.043e-02, 8.005e-02, 7.968e-02, 7.931e-02, 7.894e-02, 7.857e-02, 7.821e-02, 7.786e-02, 7.750e-02, 7.715e-02, 7.680e-02, 7.646e-02, - 7.611e-02, 7.578e-02, 7.544e-02, 7.461e-02, 7.380e-02, 7.301e-02, 7.224e-02, 7.148e-02, 7.074e-02, 7.001e-02, 6.930e-02, 6.860e-02, - 6.792e-02, 6.659e-02, 6.532e-02, 6.409e-02, 6.291e-02, 6.177e-02, 6.067e-02, 5.961e-02, 5.859e-02, 5.760e-02, 5.664e-02, 5.572e-02, - 5.482e-02, 5.395e-02, 5.312e-02, 3.542e-05, 4.724e-02, 4.418e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.13040, 0.12840, 0.12650, 0.12580, 0.125, 0.12430, 0.12360, 0.12290, 0.12220, 0.12150, 0.12080, - 0.12010, 0.11940, 0.11870, 0.11810, 0.11740, 0.11680, 0.11650, 0.11620, 0.11580, 0.11550, 0.11520, 0.11490, - 0.11460, 0.11430, 0.114, 0.11370, 0.11340, 0.11310, 0.11280, 0.11250, 0.11220, 0.11190, 0.11160, 0.11130, - 0.111, 0.11080, 0.11050, 0.11020, 0.10990, 0.10960, 0.10930, 0.10910, 0.10880, 0.10850, 0.10820, 0.108, - 0.10770, 0.10740, 0.10690, 0.10640, 0.10580, 0.10530, 0.10480, 0.10430, 0.10380, 0.10330, 0.10280, 0.10230, - 0.10180, 0.10130, 0.10090, 0.10040, 9.993e-02, 9.946e-02, 9.901e-02, 9.855e-02, 9.810e-02, 9.766e-02, 9.722e-02, 9.678e-02, - 9.635e-02, 9.592e-02, 9.549e-02, 9.444e-02, 9.342e-02, 9.242e-02, 9.144e-02, 9.048e-02, 8.954e-02, 8.862e-02, 8.771e-02, 8.683e-02, - 8.597e-02, 8.429e-02, 8.267e-02, 8.112e-02, 7.962e-02, 7.818e-02, 7.678e-02, 7.544e-02, 7.415e-02, 7.289e-02, 7.168e-02, 7.051e-02, - 6.938e-02, 6.828e-02, 6.722e-02, 3.542e-05, 5.978e-02, 5.591e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.16150, 0.159, 0.15810, 0.15710, 0.15620, 0.15530, 0.15440, 0.15350, 0.15260, 0.15180, - 0.15090, 0.15, 0.14920, 0.14840, 0.14760, 0.14670, 0.14630, 0.14590, 0.14550, 0.14520, 0.14480, 0.14440, - 0.144, 0.14360, 0.14320, 0.14280, 0.14250, 0.14210, 0.14170, 0.14130, 0.141, 0.14060, 0.14020, 0.13990, - 0.13950, 0.13910, 0.13880, 0.13840, 0.13810, 0.13770, 0.13730, 0.137, 0.13660, 0.13630, 0.136, 0.13560, - 0.13530, 0.13490, 0.13430, 0.13360, 0.13290, 0.13230, 0.13160, 0.131, 0.13040, 0.12970, 0.12910, 0.12850, - 0.12790, 0.12730, 0.12670, 0.12610, 0.12550, 0.12490, 0.12430, 0.12380, 0.12320, 0.12260, 0.12210, 0.12150, - 0.121, 0.12050, 0.11990, 0.11860, 0.11730, 0.11610, 0.11480, 0.11360, 0.11240, 0.11130, 0.11010, 0.109, - 0.10790, 0.10580, 0.10380, 0.10190, 9.997e-02, 9.816e-02, 9.641e-02, 9.473e-02, 9.310e-02, 9.152e-02, 9.000e-02, 8.853e-02, - 8.711e-02, 8.573e-02, 8.440e-02, 3.542e-05, 7.505e-02, 7.019e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.19840, 0.19720, 0.19610, 0.19490, 0.19370, 0.19260, 0.19150, 0.19040, 0.18930, 0.18820, 0.18720, - 0.18610, 0.18510, 0.184, 0.183, 0.18250, 0.182, 0.18150, 0.181, 0.18050, 0.18, 0.17960, 0.17910, 0.17860, - 0.17810, 0.17760, 0.17720, 0.17670, 0.17620, 0.17580, 0.17530, 0.17480, 0.17440, 0.17390, 0.17350, 0.173, 0.17260, - 0.17210, 0.17170, 0.17120, 0.17080, 0.17040, 0.16990, 0.16950, 0.16910, 0.16870, 0.16820, 0.16740, 0.16660, 0.16570, - 0.16490, 0.16410, 0.16330, 0.16250, 0.16170, 0.16090, 0.16020, 0.15940, 0.15870, 0.15790, 0.15720, 0.15640, 0.15570, - 0.155, 0.15430, 0.15360, 0.15290, 0.15220, 0.15150, 0.15080, 0.15010, 0.14950, 0.14780, 0.14620, 0.14460, 0.14310, - 0.14160, 0.14010, 0.13870, 0.13730, 0.13590, 0.13450, 0.13190, 0.12940, 0.12690, 0.12460, 0.12230, 0.12010, 0.118, - 0.116, 0.11410, 0.11220, 0.11030, 0.10850, 0.10680, 0.10520, 3.542e-05, 9.352e-02, 8.746e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.21510, 0.21380, 0.21250, 0.21130, 0.21, 0.20880, 0.20760, 0.20640, 0.20520, 0.204, 0.20290, 0.20180, 0.20060, 0.19950, - 0.199, 0.19840, 0.19790, 0.19730, 0.19680, 0.19630, 0.19570, 0.19520, 0.19470, 0.19420, 0.19360, 0.19310, 0.19260, 0.19210, 0.19160, - 0.19110, 0.19060, 0.19010, 0.18960, 0.18910, 0.18860, 0.18810, 0.18760, 0.18720, 0.18670, 0.18620, 0.18570, 0.18520, 0.18480, 0.18430, - 0.18380, 0.18340, 0.18250, 0.18150, 0.18060, 0.17980, 0.17890, 0.178, 0.17710, 0.17630, 0.17540, 0.17460, 0.17380, 0.17290, 0.17210, - 0.17130, 0.17050, 0.16970, 0.16890, 0.16820, 0.16740, 0.16660, 0.16590, 0.16510, 0.16440, 0.16360, 0.16290, 0.16110, 0.15940, 0.15770, - 0.156, 0.15430, 0.15270, 0.15110, 0.14960, 0.14810, 0.14660, 0.14370, 0.141, 0.13830, 0.13580, 0.13330, 0.13090, 0.12860, 0.12640, - 0.12430, 0.12220, 0.12020, 0.11830, 0.11640, 0.11460, 3.542e-05, 0.10190, 9.531e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.23290, 0.23150, 0.23010, 0.22870, 0.22740, 0.22610, 0.22480, 0.22350, 0.22220, 0.221, 0.21970, 0.21850, 0.21730, - 0.21670, 0.21610, 0.21550, 0.21490, 0.21430, 0.21370, 0.21310, 0.21260, 0.212, 0.21140, 0.21090, 0.21030, 0.20970, 0.20920, 0.20860, - 0.20810, 0.20750, 0.207, 0.20640, 0.20590, 0.20540, 0.20480, 0.20430, 0.20380, 0.20330, 0.20270, 0.20220, 0.20170, 0.20120, 0.20070, - 0.20020, 0.19970, 0.19870, 0.19770, 0.19670, 0.19570, 0.19480, 0.19380, 0.19290, 0.19190, 0.191, 0.19010, 0.18920, 0.18830, 0.18740, - 0.18650, 0.18560, 0.18480, 0.18390, 0.18310, 0.18220, 0.18140, 0.18060, 0.17980, 0.179, 0.17820, 0.17740, 0.17540, 0.17350, 0.17160, - 0.16980, 0.168, 0.16630, 0.16450, 0.16290, 0.16120, 0.15960, 0.15650, 0.15350, 0.15060, 0.14780, 0.14510, 0.14250, 0.14, 0.13760, - 0.13530, 0.133, 0.13090, 0.12880, 0.12670, 0.12480, 3.542e-05, 0.11090, 0.1037}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.25180, 0.25030, 0.24890, 0.24740, 0.246, 0.24450, 0.24310, 0.24170, 0.24040, 0.239, 0.23770, 0.23640, - 0.23570, 0.23510, 0.23440, 0.23380, 0.23310, 0.23250, 0.23190, 0.23120, 0.23060, 0.23, 0.22940, 0.22880, 0.22810, 0.22750, 0.22690, - 0.22630, 0.22570, 0.22510, 0.22460, 0.224, 0.22340, 0.22280, 0.22220, 0.22160, 0.22110, 0.22050, 0.21990, 0.21940, 0.21880, 0.21830, - 0.21770, 0.21720, 0.21610, 0.215, 0.21390, 0.21290, 0.21180, 0.21080, 0.20970, 0.20870, 0.20770, 0.20670, 0.20570, 0.20480, 0.20380, - 0.20280, 0.20190, 0.201, 0.2, 0.19910, 0.19820, 0.19730, 0.19640, 0.19550, 0.19460, 0.19370, 0.19290, 0.19080, 0.18870, 0.18660, - 0.18470, 0.18270, 0.18080, 0.17890, 0.17710, 0.17530, 0.17360, 0.17020, 0.16690, 0.16370, 0.16070, 0.15780, 0.155, 0.15230, 0.14960, - 0.14710, 0.14470, 0.14230, 0.14, 0.13780, 0.13560, 3.542e-05, 0.12060, 0.1128}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.27210, 0.27050, 0.26890, 0.26730, 0.26580, 0.26420, 0.26270, 0.26120, 0.25970, 0.25830, 0.25680, - 0.25610, 0.25540, 0.25470, 0.254, 0.25330, 0.25260, 0.25190, 0.25130, 0.25060, 0.24990, 0.24920, 0.24860, 0.24790, 0.24720, 0.24660, - 0.24590, 0.24530, 0.24460, 0.244, 0.24330, 0.24270, 0.24210, 0.24140, 0.24080, 0.24020, 0.23960, 0.239, 0.23840, 0.23770, 0.23710, - 0.23650, 0.23590, 0.23480, 0.23360, 0.23240, 0.23130, 0.23010, 0.229, 0.22790, 0.22680, 0.22570, 0.22460, 0.22350, 0.22250, 0.22140, - 0.22040, 0.21930, 0.21830, 0.21730, 0.21630, 0.21530, 0.21430, 0.21330, 0.21240, 0.21140, 0.21050, 0.20950, 0.20720, 0.205, 0.20270, - 0.20060, 0.19850, 0.19640, 0.19440, 0.19240, 0.19040, 0.18850, 0.18480, 0.18130, 0.17790, 0.17460, 0.17140, 0.16830, 0.16540, 0.16250, - 0.15980, 0.15710, 0.15460, 0.15210, 0.14970, 0.14730, 3.542e-05, 0.131, 0.1225}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.29370, 0.29190, 0.29020, 0.28850, 0.28690, 0.28520, 0.28360, 0.282, 0.28040, 0.27880, - 0.278, 0.27730, 0.27650, 0.27570, 0.275, 0.27420, 0.27350, 0.27270, 0.272, 0.27130, 0.27050, 0.26980, 0.26910, 0.26840, 0.26760, - 0.26690, 0.26620, 0.26550, 0.26480, 0.26410, 0.26340, 0.26280, 0.26210, 0.26140, 0.26070, 0.26, 0.25940, 0.25870, 0.258, 0.25740, - 0.25670, 0.25610, 0.25480, 0.25350, 0.25220, 0.251, 0.24980, 0.24850, 0.24730, 0.24610, 0.24490, 0.24370, 0.24260, 0.24140, 0.24030, - 0.23910, 0.238, 0.23690, 0.23580, 0.23470, 0.23360, 0.23260, 0.23150, 0.23050, 0.22940, 0.22840, 0.22740, 0.22490, 0.22240, 0.22, - 0.21770, 0.21540, 0.21310, 0.21090, 0.20880, 0.20660, 0.20460, 0.20060, 0.19670, 0.193, 0.18940, 0.186, 0.18270, 0.17950, 0.17640, - 0.17340, 0.17050, 0.16770, 0.165, 0.16240, 0.15990, 3.542e-05, 0.14210, 0.1329}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31660, 0.31480, 0.31290, 0.31110, 0.30930, 0.30760, 0.30580, 0.30410, 0.30240, - 0.30150, 0.30070, 0.29990, 0.299, 0.29820, 0.29740, 0.29660, 0.29580, 0.295, 0.29420, 0.29340, 0.29260, 0.29180, 0.291, 0.29020, - 0.28940, 0.28870, 0.28790, 0.28720, 0.28640, 0.28560, 0.28490, 0.28420, 0.28340, 0.28270, 0.282, 0.28120, 0.28050, 0.27980, 0.27910, - 0.27840, 0.27760, 0.27620, 0.27490, 0.27350, 0.27210, 0.27080, 0.26940, 0.26810, 0.26680, 0.26550, 0.26430, 0.263, 0.26170, 0.26050, - 0.25930, 0.258, 0.25680, 0.25560, 0.25450, 0.25330, 0.25210, 0.251, 0.24980, 0.24870, 0.24760, 0.24650, 0.24380, 0.24110, 0.23850, - 0.23590, 0.23350, 0.231, 0.22860, 0.22630, 0.224, 0.22170, 0.21740, 0.21320, 0.20920, 0.20530, 0.20160, 0.198, 0.19450, 0.19120, - 0.18790, 0.18480, 0.18180, 0.17880, 0.176, 0.17330, 3.542e-05, 0.154, 0.1441}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.34110, 0.33910, 0.33710, 0.33520, 0.33320, 0.33130, 0.32940, 0.32760, - 0.32670, 0.32580, 0.32490, 0.324, 0.32310, 0.32220, 0.32130, 0.32040, 0.31950, 0.31870, 0.31780, 0.31690, 0.31610, 0.31520, 0.31440, - 0.31350, 0.31270, 0.31190, 0.31110, 0.31020, 0.30940, 0.30860, 0.30780, 0.307, 0.30620, 0.30540, 0.30460, 0.30380, 0.30310, 0.30230, - 0.30150, 0.30070, 0.29920, 0.29770, 0.29620, 0.29470, 0.29330, 0.29180, 0.29040, 0.289, 0.28760, 0.28620, 0.28480, 0.28350, 0.28210, - 0.28080, 0.27950, 0.27820, 0.27690, 0.27560, 0.27430, 0.27310, 0.27180, 0.27060, 0.26930, 0.26810, 0.26690, 0.264, 0.26110, 0.25830, - 0.25550, 0.25280, 0.25020, 0.24760, 0.245, 0.24260, 0.24010, 0.23540, 0.23090, 0.22650, 0.22230, 0.21830, 0.21440, 0.21060, 0.207, - 0.20350, 0.20010, 0.19680, 0.19360, 0.19060, 0.18760, 3.542e-05, 0.16680, 0.156}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.36710, 0.36490, 0.36280, 0.36070, 0.35860, 0.35660, 0.35460, - 0.35360, 0.35260, 0.35160, 0.35060, 0.34960, 0.34870, 0.34770, 0.34680, 0.34580, 0.34490, 0.34390, 0.343, 0.34210, 0.34110, 0.34020, - 0.33930, 0.33840, 0.33750, 0.33660, 0.33570, 0.33480, 0.334, 0.33310, 0.33220, 0.33130, 0.33050, 0.32960, 0.32880, 0.32790, 0.32710, - 0.32630, 0.32540, 0.32380, 0.32210, 0.32050, 0.31890, 0.31730, 0.31580, 0.31420, 0.31270, 0.31120, 0.30970, 0.30820, 0.30670, 0.30520, - 0.30380, 0.30240, 0.30090, 0.29950, 0.29820, 0.29680, 0.29540, 0.29410, 0.29270, 0.29140, 0.29010, 0.28880, 0.28560, 0.28250, 0.27940, - 0.27640, 0.27350, 0.27060, 0.26780, 0.26510, 0.26240, 0.25980, 0.25460, 0.24970, 0.245, 0.24050, 0.23610, 0.23190, 0.22780, 0.22390, - 0.22010, 0.21640, 0.21290, 0.20940, 0.20610, 0.20290, 3.542e-05, 0.18040, 0.1687}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.39460, 0.39230, 0.39010, 0.38780, 0.38560, 0.38340, - 0.38230, 0.38120, 0.38020, 0.37910, 0.37810, 0.377, 0.376, 0.37490, 0.37390, 0.37290, 0.37190, 0.37080, 0.36980, 0.36880, 0.36780, - 0.36690, 0.36590, 0.36490, 0.36390, 0.363, 0.362, 0.361, 0.36010, 0.35920, 0.35820, 0.35730, 0.35640, 0.35540, 0.35450, 0.35360, - 0.35270, 0.35180, 0.35, 0.34820, 0.34650, 0.34470, 0.343, 0.34130, 0.33970, 0.338, 0.33640, 0.33470, 0.33310, 0.33150, 0.32990, - 0.32840, 0.32680, 0.32530, 0.32380, 0.32230, 0.32080, 0.31930, 0.31780, 0.31640, 0.315, 0.31350, 0.31210, 0.30870, 0.30530, 0.302, - 0.29870, 0.29560, 0.29250, 0.28940, 0.28650, 0.28360, 0.28070, 0.27520, 0.26990, 0.26480, 0.25990, 0.25510, 0.25060, 0.24620, 0.24190, - 0.23780, 0.23390, 0.23, 0.22630, 0.22270, 0.21930, 3.542e-05, 0.19490, 0.1823}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42390, 0.42140, 0.419, 0.41660, 0.41420, - 0.413, 0.41190, 0.41070, 0.40960, 0.40840, 0.40730, 0.40610, 0.405, 0.40390, 0.40280, 0.40170, 0.40060, 0.39950, 0.39840, 0.39730, - 0.39630, 0.39520, 0.39410, 0.39310, 0.392, 0.391, 0.39, 0.38890, 0.38790, 0.38690, 0.38590, 0.38490, 0.38390, 0.38290, 0.38190, - 0.38090, 0.37990, 0.378, 0.37610, 0.37420, 0.37230, 0.37050, 0.36860, 0.36680, 0.365, 0.36320, 0.36150, 0.35970, 0.358, 0.35630, - 0.35460, 0.35290, 0.35130, 0.34960, 0.348, 0.34640, 0.34480, 0.34320, 0.34160, 0.34010, 0.33860, 0.337, 0.33330, 0.32960, 0.32610, - 0.32260, 0.31910, 0.31580, 0.31250, 0.30930, 0.30620, 0.30310, 0.29710, 0.29140, 0.28590, 0.28060, 0.27540, 0.27050, 0.26580, 0.26120, - 0.25680, 0.25250, 0.24830, 0.24430, 0.24050, 0.23670, 3.542e-05, 0.21040, 0.1968}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.45490, 0.45230, 0.44970, 0.44710, - 0.44580, 0.44450, 0.44330, 0.442, 0.44080, 0.43960, 0.43830, 0.43710, 0.43590, 0.43470, 0.43350, 0.43230, 0.43110, 0.43, 0.42880, - 0.42760, 0.42650, 0.42530, 0.42420, 0.42310, 0.42190, 0.42080, 0.41970, 0.41860, 0.41750, 0.41640, 0.41530, 0.41420, 0.41320, 0.41210, - 0.411, 0.41, 0.40790, 0.40580, 0.40380, 0.40170, 0.39970, 0.39770, 0.39580, 0.39380, 0.39190, 0.39, 0.38810, 0.38620, 0.38440, - 0.38260, 0.38080, 0.379, 0.37720, 0.37540, 0.37370, 0.372, 0.37030, 0.36860, 0.36690, 0.36520, 0.36360, 0.35950, 0.35560, 0.35170, - 0.34790, 0.34420, 0.34060, 0.33710, 0.33360, 0.33020, 0.32690, 0.32050, 0.31430, 0.30830, 0.30260, 0.29710, 0.29180, 0.28660, 0.28170, - 0.27690, 0.27230, 0.26780, 0.26350, 0.25930, 0.25530, 3.542e-05, 0.22690, 0.2122}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.48780, 0.48490, 0.48210, - 0.48080, 0.47940, 0.478, 0.47670, 0.47530, 0.474, 0.47270, 0.47130, 0.47, 0.46870, 0.46740, 0.46620, 0.46490, 0.46360, 0.46230, - 0.46110, 0.45980, 0.45860, 0.45740, 0.45610, 0.45490, 0.45370, 0.45250, 0.45130, 0.45010, 0.44890, 0.44780, 0.44660, 0.44540, 0.44430, - 0.44310, 0.442, 0.43970, 0.43750, 0.43530, 0.43310, 0.43090, 0.42870, 0.42660, 0.42450, 0.42240, 0.42040, 0.41830, 0.41630, 0.41430, - 0.41240, 0.41040, 0.40850, 0.40650, 0.40460, 0.40280, 0.40090, 0.39910, 0.39720, 0.39540, 0.39360, 0.39190, 0.38750, 0.38320, 0.37910, - 0.375, 0.371, 0.36710, 0.36330, 0.35950, 0.35590, 0.35230, 0.34530, 0.33870, 0.33230, 0.32610, 0.32010, 0.31440, 0.30890, 0.30350, - 0.29840, 0.29340, 0.28860, 0.28390, 0.27940, 0.27510, 3.542e-05, 0.24450, 0.2287}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.52250, 0.51950, - 0.518, 0.51650, 0.51510, 0.51360, 0.51210, 0.51070, 0.50920, 0.50780, 0.50640, 0.505, 0.50360, 0.50220, 0.50080, 0.49940, 0.49810, - 0.49670, 0.49540, 0.494, 0.49270, 0.49140, 0.49010, 0.48870, 0.48740, 0.48610, 0.48490, 0.48360, 0.48230, 0.481, 0.47980, 0.47850, - 0.47730, 0.47610, 0.47360, 0.47120, 0.46880, 0.46640, 0.46410, 0.46180, 0.45950, 0.45720, 0.455, 0.45270, 0.45050, 0.44840, 0.44620, - 0.44410, 0.442, 0.43990, 0.43780, 0.43580, 0.43370, 0.43170, 0.42970, 0.42780, 0.42580, 0.42390, 0.422, 0.41730, 0.41270, 0.40820, - 0.40380, 0.39950, 0.39530, 0.39110, 0.38710, 0.38320, 0.37930, 0.37180, 0.36460, 0.35770, 0.35110, 0.34460, 0.33850, 0.33250, 0.32680, - 0.32120, 0.31590, 0.31070, 0.30570, 0.30080, 0.29610, 3.542e-05, 0.26320, 0.2461}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.55930, - 0.55770, 0.55610, 0.55450, 0.55290, 0.55130, 0.54980, 0.54820, 0.54670, 0.54510, 0.54360, 0.54210, 0.54060, 0.53910, 0.53760, 0.53610, - 0.53460, 0.53320, 0.53170, 0.53030, 0.52890, 0.52740, 0.526, 0.52460, 0.52320, 0.52180, 0.52050, 0.51910, 0.51770, 0.51640, 0.515, - 0.51370, 0.51230, 0.50970, 0.50710, 0.50450, 0.50190, 0.49940, 0.49690, 0.49440, 0.492, 0.48960, 0.48720, 0.48480, 0.48240, 0.48010, - 0.47780, 0.47550, 0.47330, 0.47110, 0.46880, 0.46670, 0.46450, 0.46230, 0.46020, 0.45810, 0.456, 0.454, 0.44890, 0.44390, 0.43910, - 0.43440, 0.42970, 0.42520, 0.42080, 0.41640, 0.41220, 0.408, 0.4, 0.39220, 0.38480, 0.37760, 0.37070, 0.36410, 0.35760, 0.35150, - 0.34550, 0.33970, 0.33410, 0.32870, 0.32350, 0.31850, 3.542e-05, 0.28310, 0.2647}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.57850, 0.57680, 0.57510, 0.57350, 0.57180, 0.57020, 0.56860, 0.567, 0.56540, 0.56380, 0.56220, 0.56070, 0.55910, 0.55760, 0.556, - 0.55450, 0.553, 0.55150, 0.55, 0.54850, 0.547, 0.54550, 0.54410, 0.54260, 0.54120, 0.53980, 0.53830, 0.53690, 0.53550, 0.53410, - 0.53270, 0.53130, 0.52860, 0.52590, 0.52320, 0.52050, 0.51790, 0.51530, 0.51270, 0.51020, 0.50770, 0.50520, 0.50270, 0.50030, 0.49790, - 0.49550, 0.49310, 0.49080, 0.48850, 0.48620, 0.48390, 0.48160, 0.47940, 0.47720, 0.475, 0.47290, 0.47070, 0.46550, 0.46030, 0.45530, - 0.45040, 0.44560, 0.44090, 0.43630, 0.43180, 0.42740, 0.423, 0.41470, 0.40660, 0.39890, 0.39150, 0.38430, 0.37740, 0.37080, 0.36440, - 0.35820, 0.35220, 0.34640, 0.34080, 0.33540, 0.33020, 3.542e-05, 0.29350, 0.2744}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.59820, 0.59640, 0.59470, 0.593, 0.59130, 0.58960, 0.588, 0.58630, 0.58470, 0.583, 0.58140, 0.57980, 0.57820, 0.57660, - 0.575, 0.57340, 0.57180, 0.57030, 0.56870, 0.56720, 0.56570, 0.56420, 0.56270, 0.56120, 0.55970, 0.55820, 0.55670, 0.55520, 0.55380, - 0.55230, 0.55090, 0.548, 0.54520, 0.54240, 0.53970, 0.53690, 0.53420, 0.53160, 0.52890, 0.52630, 0.52370, 0.52120, 0.51870, 0.51620, - 0.51370, 0.51120, 0.50880, 0.50640, 0.504, 0.50170, 0.49930, 0.497, 0.49470, 0.49250, 0.49020, 0.488, 0.48250, 0.47720, 0.472, - 0.46690, 0.46190, 0.457, 0.45220, 0.44760, 0.443, 0.43850, 0.42980, 0.42150, 0.41350, 0.40580, 0.39840, 0.39120, 0.38430, 0.37770, - 0.37130, 0.36510, 0.35910, 0.35330, 0.34760, 0.34220, 3.542e-05, 0.30420, 0.2844}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.61840, 0.61660, 0.61480, 0.61310, 0.61130, 0.60960, 0.60790, 0.60620, 0.60450, 0.60280, 0.60110, 0.59940, 0.59780, - 0.59610, 0.59450, 0.59280, 0.59120, 0.58960, 0.588, 0.58640, 0.58490, 0.58330, 0.58170, 0.58020, 0.57860, 0.57710, 0.57560, 0.57410, - 0.57260, 0.57110, 0.56810, 0.56520, 0.56230, 0.55940, 0.55660, 0.55380, 0.551, 0.54830, 0.54560, 0.54290, 0.54020, 0.53760, 0.535, - 0.53240, 0.52990, 0.52740, 0.52490, 0.52240, 0.52, 0.51750, 0.51510, 0.51280, 0.51040, 0.50810, 0.50580, 0.50010, 0.49460, 0.48920, - 0.48390, 0.47870, 0.47360, 0.46870, 0.46390, 0.45910, 0.45450, 0.44550, 0.43680, 0.42850, 0.42050, 0.41290, 0.40540, 0.39830, 0.39140, - 0.38470, 0.37830, 0.37210, 0.36610, 0.36030, 0.35460, 3.542e-05, 0.31520, 0.2948}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.63920, 0.63740, 0.63550, 0.63370, 0.63190, 0.63010, 0.62830, 0.62660, 0.62480, 0.623, 0.62130, 0.61960, - 0.61790, 0.61620, 0.61450, 0.61280, 0.61110, 0.60950, 0.60780, 0.60620, 0.60460, 0.60290, 0.60130, 0.59970, 0.59810, 0.59660, 0.595, - 0.59340, 0.59190, 0.58880, 0.58580, 0.58270, 0.57980, 0.57680, 0.57390, 0.571, 0.56820, 0.56540, 0.56260, 0.55990, 0.55710, 0.55440, - 0.55180, 0.54910, 0.54650, 0.54390, 0.54140, 0.53880, 0.53630, 0.53380, 0.53140, 0.52890, 0.52650, 0.52410, 0.51820, 0.51250, 0.50690, - 0.50140, 0.496, 0.49080, 0.48570, 0.48060, 0.47570, 0.47090, 0.46160, 0.45260, 0.444, 0.43570, 0.42780, 0.42010, 0.41270, 0.40550, - 0.39860, 0.392, 0.38550, 0.37930, 0.37330, 0.36740, 3.542e-05, 0.32660, 0.3054}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.66060, 0.65870, 0.65680, 0.65490, 0.653, 0.65120, 0.64930, 0.64750, 0.64570, 0.64390, 0.64210, - 0.64030, 0.63850, 0.63680, 0.635, 0.63330, 0.63160, 0.62990, 0.62820, 0.62650, 0.62480, 0.62310, 0.62150, 0.61980, 0.61820, 0.61650, - 0.61490, 0.61330, 0.61010, 0.607, 0.60380, 0.60070, 0.59770, 0.59470, 0.59170, 0.58870, 0.58580, 0.58290, 0.58010, 0.57720, 0.57440, - 0.57170, 0.56890, 0.56620, 0.56350, 0.56090, 0.55820, 0.55560, 0.55310, 0.55050, 0.548, 0.54550, 0.543, 0.53690, 0.53090, 0.52510, - 0.51940, 0.51390, 0.50840, 0.50310, 0.49790, 0.49280, 0.48780, 0.47820, 0.46890, 0.46, 0.45140, 0.44310, 0.43510, 0.42750, 0.42010, - 0.41290, 0.406, 0.39930, 0.39290, 0.38660, 0.38060, 3.542e-05, 0.33830, 0.3163}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.68250, 0.68050, 0.67860, 0.67660, 0.67470, 0.67280, 0.67090, 0.669, 0.66710, 0.66530, - 0.66340, 0.66160, 0.65980, 0.658, 0.65620, 0.65440, 0.65260, 0.65080, 0.64910, 0.64730, 0.64560, 0.64390, 0.64210, 0.64040, 0.63870, - 0.63710, 0.63540, 0.63210, 0.62880, 0.62550, 0.62230, 0.61920, 0.616, 0.61290, 0.60990, 0.60690, 0.60390, 0.60090, 0.598, 0.59510, - 0.59220, 0.58930, 0.58650, 0.58370, 0.581, 0.57830, 0.57560, 0.57290, 0.57020, 0.56760, 0.565, 0.56240, 0.55610, 0.54990, 0.54390, - 0.538, 0.53230, 0.52660, 0.52110, 0.51570, 0.51040, 0.50530, 0.49520, 0.48560, 0.47640, 0.46750, 0.45890, 0.45070, 0.44270, 0.435, - 0.42760, 0.42050, 0.41360, 0.40690, 0.40040, 0.39410, 3.542e-05, 0.35030, 0.3276}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.705, 0.703, 0.701, 0.699, 0.697, 0.695, 0.69310, 0.69110, 0.68920, - 0.68730, 0.68530, 0.68350, 0.68160, 0.67970, 0.67780, 0.676, 0.67420, 0.67230, 0.67050, 0.66870, 0.66690, 0.66510, 0.66340, 0.66160, - 0.65990, 0.65810, 0.65470, 0.65130, 0.64790, 0.64460, 0.64130, 0.63810, 0.63480, 0.63170, 0.62850, 0.62540, 0.62230, 0.61930, 0.61630, - 0.61330, 0.61040, 0.60740, 0.60460, 0.60170, 0.59890, 0.59610, 0.59330, 0.59050, 0.58780, 0.58510, 0.58250, 0.57590, 0.56950, 0.56330, - 0.55710, 0.55120, 0.54530, 0.53960, 0.534, 0.52860, 0.52320, 0.51280, 0.50280, 0.49330, 0.484, 0.47520, 0.46660, 0.45840, 0.45050, - 0.44280, 0.43540, 0.42820, 0.42130, 0.41460, 0.40810, 3.542e-05, 0.36270, 0.3391}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.72820, 0.72610, 0.724, 0.72190, 0.71990, 0.71780, 0.71580, 0.71380, - 0.71180, 0.70980, 0.70790, 0.70590, 0.704, 0.702, 0.70010, 0.69820, 0.69630, 0.69440, 0.69250, 0.69070, 0.68880, 0.687, 0.68520, - 0.68340, 0.68160, 0.678, 0.67450, 0.671, 0.66750, 0.66410, 0.66070, 0.65740, 0.65410, 0.65080, 0.64760, 0.64440, 0.64130, 0.63810, - 0.63510, 0.632, 0.629, 0.626, 0.623, 0.62010, 0.61720, 0.61430, 0.61150, 0.60860, 0.60580, 0.60310, 0.59630, 0.58960, 0.58320, - 0.57680, 0.57060, 0.56460, 0.55870, 0.55290, 0.54720, 0.54170, 0.53090, 0.52060, 0.51060, 0.50110, 0.49190, 0.48310, 0.47450, 0.46630, - 0.45840, 0.45070, 0.44330, 0.43610, 0.42920, 0.42240, 3.542e-05, 0.37540, 0.3511}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75190, 0.74970, 0.74760, 0.74550, 0.74330, 0.74120, 0.73920, - 0.73710, 0.735, 0.733, 0.73090, 0.72890, 0.72690, 0.72490, 0.723, 0.721, 0.719, 0.71710, 0.71520, 0.71320, 0.71130, 0.70940, - 0.70760, 0.70570, 0.702, 0.69830, 0.69470, 0.69110, 0.68760, 0.68410, 0.68060, 0.67720, 0.67380, 0.67050, 0.66720, 0.66390, 0.66060, - 0.65740, 0.65430, 0.65110, 0.648, 0.645, 0.64190, 0.63890, 0.63590, 0.633, 0.63010, 0.62720, 0.62430, 0.61730, 0.61040, 0.60370, - 0.59710, 0.59070, 0.58440, 0.57830, 0.57230, 0.56640, 0.56070, 0.54950, 0.53880, 0.52850, 0.51870, 0.50910, 0.5, 0.49120, 0.48260, - 0.47440, 0.46650, 0.45880, 0.45140, 0.44420, 0.43720, 3.542e-05, 0.38860, 0.3633}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.77630, 0.774, 0.77180, 0.76960, 0.76740, 0.76530, - 0.76310, 0.761, 0.75890, 0.75670, 0.75470, 0.75260, 0.75050, 0.74840, 0.74640, 0.74440, 0.74240, 0.74040, 0.73840, 0.73640, 0.73440, - 0.73250, 0.73050, 0.72670, 0.72290, 0.71910, 0.71540, 0.71170, 0.70810, 0.70450, 0.701, 0.69750, 0.694, 0.69060, 0.68720, 0.68380, - 0.68050, 0.67720, 0.674, 0.67070, 0.66760, 0.66440, 0.66130, 0.65820, 0.65510, 0.65210, 0.64910, 0.64610, 0.63880, 0.63170, 0.62480, - 0.618, 0.61130, 0.60480, 0.59850, 0.59230, 0.58620, 0.58020, 0.56870, 0.55760, 0.547, 0.53670, 0.52690, 0.51740, 0.50820, 0.49940, - 0.49090, 0.48270, 0.47470, 0.46710, 0.45960, 0.45240, 3.542e-05, 0.40210, 0.3759}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.80130, 0.799, 0.79670, 0.79440, 0.79220, - 0.78990, 0.78770, 0.78550, 0.78330, 0.78110, 0.779, 0.77680, 0.77470, 0.77260, 0.77050, 0.76840, 0.76630, 0.76420, 0.76220, 0.76010, - 0.75810, 0.75610, 0.75210, 0.74820, 0.74430, 0.74040, 0.73660, 0.73280, 0.72910, 0.72540, 0.72180, 0.71820, 0.71470, 0.71110, 0.70770, - 0.70420, 0.70080, 0.69740, 0.69410, 0.69080, 0.68750, 0.68430, 0.68110, 0.67790, 0.67480, 0.67170, 0.66860, 0.661, 0.65370, 0.64650, - 0.63940, 0.63250, 0.62580, 0.61920, 0.61280, 0.60650, 0.60030, 0.58840, 0.57690, 0.56590, 0.55530, 0.54510, 0.53530, 0.52580, 0.51670, - 0.50790, 0.49940, 0.49110, 0.48320, 0.47550, 0.468, 3.542e-05, 0.41590, 0.3889}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.82690, 0.82460, 0.82220, 0.81990, - 0.81750, 0.81520, 0.81290, 0.81070, 0.80840, 0.80620, 0.80390, 0.80170, 0.79950, 0.79730, 0.79520, 0.793, 0.79090, 0.78870, 0.78660, - 0.78450, 0.78240, 0.77830, 0.77420, 0.77010, 0.76610, 0.76220, 0.75830, 0.75440, 0.75060, 0.74690, 0.74310, 0.73940, 0.73580, 0.73220, - 0.72860, 0.72510, 0.72160, 0.71810, 0.71470, 0.71130, 0.708, 0.70470, 0.70140, 0.69810, 0.69490, 0.69170, 0.68390, 0.67630, 0.66880, - 0.66150, 0.65440, 0.64740, 0.64060, 0.63390, 0.62740, 0.621, 0.60870, 0.59680, 0.58540, 0.57440, 0.56390, 0.55370, 0.54390, 0.53450, - 0.52530, 0.51650, 0.508, 0.49980, 0.49180, 0.48410, 3.542e-05, 0.43020, 0.4023}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.85320, 0.85080, 0.84840, - 0.846, 0.84360, 0.84120, 0.83880, 0.83650, 0.83410, 0.83180, 0.82950, 0.82730, 0.825, 0.82270, 0.82050, 0.81830, 0.81610, 0.81390, - 0.81170, 0.80950, 0.80520, 0.801, 0.79680, 0.79260, 0.78850, 0.78450, 0.78050, 0.77650, 0.77260, 0.76880, 0.76490, 0.76120, 0.75740, - 0.75370, 0.75010, 0.74650, 0.74290, 0.73930, 0.73580, 0.73240, 0.72890, 0.72550, 0.72210, 0.71880, 0.71550, 0.70740, 0.69950, 0.69180, - 0.68420, 0.67680, 0.66960, 0.66260, 0.65570, 0.64890, 0.64230, 0.62950, 0.61720, 0.60540, 0.59410, 0.58310, 0.57260, 0.56250, 0.55270, - 0.54330, 0.53420, 0.52540, 0.51690, 0.50860, 0.50060, 3.542e-05, 0.44490, 0.416}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.88020, 0.87770, - 0.87520, 0.87270, 0.87030, 0.86780, 0.86540, 0.86290, 0.86050, 0.85820, 0.85580, 0.85340, 0.85110, 0.84880, 0.84650, 0.84420, 0.84190, - 0.83960, 0.83740, 0.83290, 0.82850, 0.82420, 0.81990, 0.81560, 0.81140, 0.80730, 0.80320, 0.79920, 0.79510, 0.79120, 0.78730, 0.78340, - 0.77960, 0.77580, 0.772, 0.76830, 0.76460, 0.761, 0.75740, 0.75390, 0.75030, 0.74680, 0.74340, 0.74, 0.73160, 0.72340, 0.71540, - 0.70760, 0.69990, 0.69240, 0.68510, 0.678, 0.671, 0.66420, 0.65090, 0.63820, 0.626, 0.61430, 0.603, 0.59210, 0.58160, 0.57150, - 0.56170, 0.55230, 0.54320, 0.53440, 0.52590, 0.51760, 3.542e-05, 0.46, 0.4301}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.90790, - 0.90530, 0.90270, 0.90020, 0.89760, 0.89510, 0.89260, 0.89010, 0.88760, 0.88520, 0.88270, 0.88030, 0.87790, 0.87550, 0.87310, 0.87070, - 0.86840, 0.86610, 0.86140, 0.85690, 0.85240, 0.84790, 0.84350, 0.83920, 0.83490, 0.83060, 0.82640, 0.82230, 0.81820, 0.81410, 0.81010, - 0.80610, 0.80220, 0.79830, 0.79450, 0.79070, 0.78690, 0.78320, 0.77950, 0.77590, 0.77220, 0.76870, 0.76510, 0.75640, 0.74790, 0.73970, - 0.73160, 0.72370, 0.71590, 0.70840, 0.701, 0.69380, 0.68670, 0.673, 0.65980, 0.64720, 0.635, 0.62340, 0.61210, 0.60130, 0.59080, - 0.58070, 0.571, 0.56150, 0.55240, 0.54360, 0.53510, 3.542e-05, 0.47550, 0.4446}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.93630, 0.93360, 0.931, 0.92830, 0.92570, 0.92310, 0.92050, 0.91790, 0.91540, 0.91280, 0.91030, 0.90780, 0.90530, 0.90290, 0.90040, - 0.898, 0.89560, 0.89080, 0.886, 0.88140, 0.87680, 0.87220, 0.86770, 0.86320, 0.85880, 0.85450, 0.85020, 0.84590, 0.84170, 0.83760, - 0.83340, 0.82940, 0.82540, 0.82140, 0.81740, 0.81350, 0.80970, 0.80590, 0.80210, 0.79840, 0.79460, 0.791, 0.782, 0.77320, 0.76460, - 0.75620, 0.74810, 0.74010, 0.73220, 0.72460, 0.71710, 0.70980, 0.69560, 0.682, 0.66890, 0.65640, 0.64430, 0.63270, 0.62150, 0.61060, - 0.60020, 0.59010, 0.58040, 0.571, 0.56190, 0.553, 3.542e-05, 0.49140, 0.4594}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.96540, 0.96260, 0.95990, 0.95720, 0.95450, 0.95180, 0.94910, 0.94650, 0.94380, 0.94120, 0.93860, 0.93610, 0.93350, 0.93090, - 0.92840, 0.92590, 0.92090, 0.916, 0.91120, 0.90640, 0.90170, 0.897, 0.89240, 0.88780, 0.88330, 0.87890, 0.87450, 0.87010, 0.86580, - 0.86150, 0.85730, 0.85320, 0.849, 0.845, 0.84090, 0.83690, 0.833, 0.82910, 0.82520, 0.82140, 0.81760, 0.80830, 0.79920, 0.79030, - 0.78160, 0.77310, 0.76490, 0.75680, 0.74890, 0.74110, 0.73360, 0.71890, 0.70480, 0.69130, 0.67830, 0.66580, 0.65380, 0.64220, 0.631, - 0.62020, 0.60980, 0.59970, 0.59, 0.58060, 0.57150, 3.542e-05, 0.50780, 0.4747}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.99520, 0.99240, 0.98950, 0.98670, 0.984, 0.98120, 0.97840, 0.97570, 0.973, 0.97030, 0.96760, 0.965, 0.96230, - 0.95970, 0.95710, 0.952, 0.94690, 0.94190, 0.93690, 0.932, 0.92720, 0.92240, 0.91770, 0.913, 0.90840, 0.90380, 0.89930, 0.89480, - 0.89040, 0.88610, 0.88170, 0.87750, 0.87320, 0.86910, 0.86490, 0.86080, 0.85680, 0.85280, 0.84880, 0.84490, 0.83520, 0.82580, 0.81670, - 0.80770, 0.79890, 0.79040, 0.782, 0.77380, 0.76580, 0.758, 0.74280, 0.72830, 0.71430, 0.70090, 0.68790, 0.67550, 0.66350, 0.652, - 0.64080, 0.63, 0.61960, 0.60960, 0.59980, 0.59040, 3.542e-05, 0.52460, 0.4905}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 1.026, 1.023, 1.02, 1.017, 1.014, 1.011, 1.008, 1.006, 1.003, 1.0, 0.99740, 0.99460, - 0.99190, 0.98920, 0.98390, 0.97860, 0.97340, 0.96830, 0.96320, 0.95820, 0.95320, 0.94830, 0.94350, 0.93870, 0.934, 0.92930, 0.92470, - 0.92010, 0.91560, 0.91110, 0.90670, 0.90230, 0.898, 0.89370, 0.88950, 0.88530, 0.88110, 0.877, 0.873, 0.863, 0.85330, 0.84380, - 0.83450, 0.82540, 0.81660, 0.80790, 0.79940, 0.79120, 0.78310, 0.76740, 0.75230, 0.73790, 0.724, 0.71060, 0.69780, 0.68540, 0.67350, - 0.66190, 0.65080, 0.64010, 0.62970, 0.61960, 0.60990, 3.542e-05, 0.54180, 0.5066}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 1.057, 1.054, 1.051, 1.048, 1.045, 1.042, 1.039, 1.036, 1.034, 1.031, 1.028, - 1.025, 1.022, 1.017, 1.011, 1.006, 1.0, 0.99520, 0.99, 0.98490, 0.97980, 0.97480, 0.96990, 0.965, 0.96010, 0.95530, - 0.95060, 0.94590, 0.94130, 0.93670, 0.93220, 0.92770, 0.92330, 0.91890, 0.91460, 0.91030, 0.906, 0.90180, 0.89150, 0.88140, 0.87160, - 0.862, 0.85260, 0.84350, 0.83450, 0.82580, 0.81720, 0.80880, 0.79260, 0.77710, 0.76210, 0.74780, 0.734, 0.72070, 0.70790, 0.69550, - 0.68360, 0.67210, 0.661, 0.65030, 0.63990, 0.62980, 3.542e-05, 0.55960, 0.5232}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 1.089, 1.086, 1.083, 1.08, 1.077, 1.074, 1.071, 1.068, 1.065, 1.062, - 1.059, 1.056, 1.05, 1.045, 1.039, 1.034, 1.028, 1.023, 1.017, 1.012, 1.007, 1.002, 0.99680, 0.99180, 0.98680, - 0.982, 0.97710, 0.97230, 0.96760, 0.96290, 0.95830, 0.95370, 0.94910, 0.94470, 0.94020, 0.93580, 0.93150, 0.92080, 0.91040, 0.90020, - 0.89030, 0.88060, 0.87110, 0.86190, 0.85280, 0.844, 0.83530, 0.81850, 0.80250, 0.787, 0.77220, 0.75790, 0.74420, 0.731, 0.71820, - 0.70590, 0.694, 0.68260, 0.67150, 0.66070, 0.65030, 3.542e-05, 0.57780, 0.5402}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.122, 1.119, 1.116, 1.113, 1.109, 1.106, 1.103, 1.1, 1.097, - 1.094, 1.091, 1.085, 1.079, 1.073, 1.068, 1.062, 1.056, 1.051, 1.045, 1.04, 1.035, 1.03, 1.024, 1.019, - 1.014, 1.009, 1.004, 0.99930, 0.99440, 0.98960, 0.98490, 0.98020, 0.97560, 0.971, 0.96640, 0.96190, 0.95090, 0.94010, 0.92960, - 0.91930, 0.90930, 0.89950, 0.88990, 0.88060, 0.87140, 0.86250, 0.84510, 0.82850, 0.81260, 0.79730, 0.78250, 0.76830, 0.75470, 0.74150, - 0.72880, 0.71650, 0.70470, 0.69320, 0.68210, 0.67140, 3.542e-05, 0.59640, 0.5576}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.156, 1.152, 1.149, 1.146, 1.143, 1.139, 1.136, 1.133, - 1.13, 1.127, 1.121, 1.115, 1.109, 1.103, 1.097, 1.091, 1.085, 1.08, 1.074, 1.069, 1.063, 1.058, 1.052, - 1.047, 1.042, 1.037, 1.032, 1.027, 1.022, 1.017, 1.012, 1.007, 1.003, 0.99790, 0.99320, 0.98180, 0.97060, 0.95970, - 0.94910, 0.93880, 0.92860, 0.91880, 0.90910, 0.89960, 0.89040, 0.87250, 0.85530, 0.83880, 0.823, 0.80780, 0.79310, 0.779, 0.76540, - 0.75230, 0.73960, 0.72740, 0.71550, 0.70410, 0.693, 3.542e-05, 0.61560, 0.5755}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.19, 1.187, 1.183, 1.18, 1.177, 1.173, 1.17, - 1.167, 1.164, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.121, 1.115, 1.109, 1.103, 1.098, 1.092, 1.087, - 1.081, 1.076, 1.071, 1.065, 1.06, 1.055, 1.05, 1.045, 1.04, 1.035, 1.03, 1.025, 1.013, 1.002, 0.99070, - 0.97970, 0.969, 0.95860, 0.94840, 0.93840, 0.92860, 0.919, 0.90050, 0.88280, 0.86580, 0.84940, 0.83370, 0.81860, 0.804, 0.78990, - 0.77640, 0.76330, 0.75070, 0.73840, 0.72660, 0.71520, 3.542e-05, 0.63530, 0.5939}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.226, 1.222, 1.219, 1.215, 1.212, 1.208, - 1.205, 1.202, 1.195, 1.188, 1.182, 1.176, 1.169, 1.163, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.122, - 1.116, 1.111, 1.105, 1.1, 1.094, 1.089, 1.084, 1.079, 1.073, 1.068, 1.063, 1.058, 1.046, 1.034, 1.023, - 1.011, 1.0, 0.98930, 0.97870, 0.96840, 0.95830, 0.94840, 0.92930, 0.911, 0.89340, 0.87650, 0.86030, 0.84470, 0.82960, 0.81510, - 0.80110, 0.78760, 0.77460, 0.76190, 0.74970, 0.73790, 3.542e-05, 0.65550, 0.6128}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.262, 1.258, 1.254, 1.251, 1.247, - 1.244, 1.24, 1.234, 1.227, 1.22, 1.213, 1.207, 1.201, 1.194, 1.188, 1.182, 1.176, 1.17, 1.164, 1.158, - 1.152, 1.146, 1.141, 1.135, 1.129, 1.124, 1.118, 1.113, 1.108, 1.102, 1.097, 1.092, 1.08, 1.067, 1.055, - 1.043, 1.032, 1.021, 1.01, 0.99920, 0.98880, 0.97860, 0.95890, 0.93990, 0.92180, 0.90440, 0.88760, 0.87150, 0.85590, 0.84090, - 0.82650, 0.81260, 0.79910, 0.78610, 0.77350, 0.76130, 3.542e-05, 0.67620, 0.6321}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.299, 1.295, 1.291, 1.288, - 1.284, 1.28, 1.273, 1.266, 1.259, 1.252, 1.246, 1.239, 1.232, 1.226, 1.22, 1.213, 1.207, 1.201, 1.195, - 1.189, 1.183, 1.177, 1.171, 1.165, 1.16, 1.154, 1.149, 1.143, 1.138, 1.132, 1.127, 1.114, 1.101, 1.089, - 1.077, 1.065, 1.053, 1.042, 1.031, 1.02, 1.01, 0.98920, 0.96960, 0.95090, 0.93290, 0.91560, 0.89890, 0.88290, 0.86740, - 0.85250, 0.83810, 0.82420, 0.81080, 0.79780, 0.78520, 3.542e-05, 0.69740, 0.652}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.337, 1.333, 1.329, - 1.325, 1.321, 1.314, 1.307, 1.3, 1.292, 1.285, 1.279, 1.272, 1.265, 1.258, 1.252, 1.245, 1.239, 1.233, - 1.227, 1.22, 1.214, 1.208, 1.202, 1.196, 1.191, 1.185, 1.179, 1.174, 1.168, 1.163, 1.149, 1.136, 1.123, - 1.111, 1.098, 1.086, 1.075, 1.063, 1.052, 1.041, 1.02, 1.0, 0.98080, 0.96220, 0.94430, 0.92710, 0.91060, 0.89460, - 0.87920, 0.86440, 0.85, 0.83620, 0.82280, 0.80980, 3.542e-05, 0.7192, 0.6723}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.375, 1.371, - 1.367, 1.364, 1.356, 1.348, 1.341, 1.334, 1.326, 1.319, 1.312, 1.305, 1.298, 1.292, 1.285, 1.278, 1.272, - 1.265, 1.259, 1.253, 1.246, 1.24, 1.234, 1.228, 1.222, 1.216, 1.211, 1.205, 1.199, 1.185, 1.172, 1.158, - 1.145, 1.133, 1.12, 1.108, 1.097, 1.085, 1.074, 1.052, 1.031, 1.011, 0.99220, 0.97380, 0.956, 0.939, 0.92250, - 0.90660, 0.89130, 0.87650, 0.86220, 0.84840, 0.835, 3.542e-05, 0.7416, 0.6932}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.415, - 1.411, 1.407, 1.399, 1.391, 1.383, 1.376, 1.368, 1.361, 1.354, 1.346, 1.339, 1.332, 1.325, 1.319, 1.312, - 1.305, 1.299, 1.292, 1.286, 1.279, 1.273, 1.267, 1.261, 1.255, 1.249, 1.243, 1.237, 1.222, 1.208, 1.195, - 1.181, 1.168, 1.155, 1.143, 1.131, 1.119, 1.107, 1.085, 1.063, 1.043, 1.023, 1.004, 0.98570, 0.96810, 0.95110, - 0.93470, 0.91890, 0.90360, 0.88890, 0.87460, 0.86080, 3.542e-05, 0.7645, 0.7146}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 1.455, 1.451, 1.443, 1.435, 1.427, 1.419, 1.411, 1.404, 1.396, 1.389, 1.381, 1.374, 1.367, 1.36, 1.353, - 1.346, 1.339, 1.332, 1.326, 1.319, 1.313, 1.306, 1.3, 1.294, 1.287, 1.281, 1.275, 1.26, 1.246, 1.232, - 1.218, 1.204, 1.191, 1.178, 1.166, 1.154, 1.142, 1.118, 1.096, 1.075, 1.055, 1.035, 1.016, 0.99790, 0.98040, - 0.96350, 0.94720, 0.93140, 0.91620, 0.90150, 0.88730, 3.542e-05, 0.7879, 0.7365}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.497, 1.488, 1.48, 1.472, 1.464, 1.456, 1.448, - 1.44, 1.432, 1.425, 1.417, 1.41, 1.402, 1.395, 1.388, 1.381, 1.374, 1.367, 1.36, 1.354, 1.347, 1.34, 1.334, 1.327, - 1.321, 1.315, 1.299, 1.284, 1.27, 1.255, 1.242, 1.228, 1.215, 1.202, 1.189, 1.177, 1.153, 1.13, 1.108, 1.087, 1.067, - 1.047, 1.028, 1.01, 0.993, 0.97620, 0.95990, 0.94420, 0.92910, 0.91440, 3.542e-05, 0.812, 0.759}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.583, 1.574, 1.565, 1.556, 1.548, 1.539, - 1.531, 1.522, 1.514, 1.506, 1.498, 1.49, 1.483, 1.475, 1.468, 1.46, 1.453, 1.445, 1.438, 1.431, 1.424, 1.417, 1.41, - 1.404, 1.397, 1.38, 1.364, 1.349, 1.334, 1.319, 1.304, 1.29, 1.276, 1.263, 1.25, 1.224, 1.2, 1.177, 1.154, 1.133, - 1.112, 1.092, 1.073, 1.054, 1.036, 1.019, 1.002, 0.98630, 0.97070, 3.542e-05, 0.8619, 0.8056}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.673, 1.663, 1.654, 1.644, 1.635, - 1.626, 1.617, 1.609, 1.6, 1.592, 1.583, 1.575, 1.567, 1.559, 1.551, 1.543, 1.535, 1.527, 1.52, 1.512, 1.505, 1.498, - 1.49, 1.483, 1.466, 1.449, 1.432, 1.416, 1.4, 1.385, 1.37, 1.355, 1.341, 1.327, 1.299, 1.273, 1.249, 1.225, 1.202, - 1.18, 1.159, 1.138, 1.119, 1.1, 1.081, 1.063, 1.046, 1.03, 3.542e-05, 0.9143, 0.8546}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.766, 1.756, 1.746, 1.737, - 1.727, 1.717, 1.708, 1.699, 1.69, 1.681, 1.672, 1.663, 1.655, 1.646, 1.638, 1.629, 1.621, 1.613, 1.605, 1.597, 1.589, - 1.582, 1.574, 1.555, 1.537, 1.519, 1.502, 1.485, 1.469, 1.453, 1.437, 1.422, 1.407, 1.378, 1.351, 1.324, 1.299, 1.274, - 1.251, 1.229, 1.207, 1.186, 1.166, 1.146, 1.128, 1.109, 1.092, 3.542e-05, 0.9692, 0.9059}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.864, 1.854, 1.843, - 1.833, 1.823, 1.813, 1.803, 1.793, 1.784, 1.774, 1.765, 1.755, 1.746, 1.737, 1.729, 1.72, 1.711, 1.703, 1.694, 1.686, - 1.678, 1.669, 1.649, 1.63, 1.611, 1.593, 1.575, 1.557, 1.54, 1.524, 1.507, 1.492, 1.461, 1.432, 1.403, 1.377, 1.351, - 1.326, 1.302, 1.279, 1.257, 1.235, 1.215, 1.195, 1.175, 1.157, 3.542e-05, 1.027, 0.9597}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.967, 1.955, 1.944, 1.933, 1.923, 1.912, 1.902, 1.891, 1.881, 1.871, - 1.861, 1.852, 1.842, 1.833, 1.823, 1.814, 1.805, 1.796, 1.787, 1.778, 1.77, 1.748, 1.728, 1.707, 1.688, 1.669, 1.65, 1.632, 1.614, - 1.597, 1.58, 1.548, 1.516, 1.487, 1.458, 1.431, 1.404, 1.379, 1.354, 1.331, 1.308, 1.286, 1.265, 1.245, 1.225, 3.542e-05, 1.087, 1.016}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.074, 2.062, 2.05, 2.038, 2.027, 2.016, 2.005, 1.994, 1.983, - 1.973, 1.962, 1.952, 1.942, 1.932, 1.922, 1.912, 1.903, 1.893, 1.884, 1.875, 1.852, 1.83, 1.809, 1.788, 1.767, 1.748, 1.728, 1.709, - 1.691, 1.673, 1.639, 1.605, 1.574, 1.543, 1.514, 1.486, 1.459, 1.434, 1.409, 1.384, 1.361, 1.339, 1.317, 1.296, 3.542e-05, 1.15, 1.075}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.185, 2.172, 2.16, 2.148, 2.136, 2.124, 2.112, 2.101, - 2.09, 2.079, 2.068, 2.057, 2.046, 2.036, 2.025, 2.015, 2.005, 1.995, 1.985, 1.961, 1.937, 1.915, 1.892, 1.871, 1.85, 1.829, 1.809, - 1.79, 1.771, 1.734, 1.699, 1.665, 1.633, 1.602, 1.572, 1.544, 1.516, 1.49, 1.464, 1.44, 1.416, 1.393, 1.371, 3.542e-05, 1.216, 1.137}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.301, 2.288, 2.275, 2.262, 2.249, 2.237, 2.225, - 2.213, 2.201, 2.189, 2.177, 2.166, 2.155, 2.144, 2.133, 2.122, 2.111, 2.101, 2.075, 2.05, 2.026, 2.002, 1.979, 1.957, 1.935, 1.914, - 1.893, 1.873, 1.834, 1.796, 1.761, 1.727, 1.694, 1.662, 1.632, 1.603, 1.575, 1.548, 1.522, 1.497, 1.473, 1.449, 3.542e-05, 1.286, 1.201}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.422, 2.408, 2.394, 2.381, 2.367, 2.354, - 2.341, 2.329, 2.316, 2.304, 2.292, 2.28, 2.268, 2.256, 2.245, 2.233, 2.222, 2.195, 2.168, 2.142, 2.117, 2.093, 2.069, 2.046, 2.023, - 2.001, 1.98, 1.938, 1.899, 1.861, 1.825, 1.79, 1.757, 1.725, 1.694, 1.664, 1.635, 1.608, 1.581, 1.556, 1.531, 3.542e-05, 1.358, 1.269}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.548, 2.533, 2.519, 2.505, 2.491, - 2.477, 2.463, 2.45, 2.437, 2.424, 2.411, 2.398, 2.386, 2.373, 2.361, 2.349, 2.32, 2.292, 2.264, 2.238, 2.212, 2.186, 2.162, 2.138, - 2.114, 2.091, 2.048, 2.006, 1.965, 1.927, 1.89, 1.855, 1.821, 1.789, 1.757, 1.727, 1.698, 1.67, 1.642, 1.616, 3.542e-05, 1.433, 1.339}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.679, 2.664, 2.648, 2.633, - 2.619, 2.604, 2.59, 2.576, 2.562, 2.548, 2.535, 2.522, 2.508, 2.495, 2.483, 2.452, 2.421, 2.392, 2.364, 2.336, 2.309, 2.283, 2.258, - 2.233, 2.209, 2.162, 2.117, 2.075, 2.034, 1.995, 1.958, 1.922, 1.888, 1.854, 1.822, 1.792, 1.762, 1.733, 1.705, 3.542e-05, 1.512, 1.413}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.816, 2.8, 2.783, - 2.768, 2.752, 2.737, 2.722, 2.707, 2.692, 2.678, 2.664, 2.65, 2.636, 2.622, 2.589, 2.557, 2.526, 2.496, 2.466, 2.438, 2.41, 2.383, - 2.357, 2.331, 2.282, 2.234, 2.189, 2.146, 2.105, 2.066, 2.028, 1.991, 1.956, 1.922, 1.89, 1.858, 1.828, 1.799, 3.542e-05, 1.595, 1.490}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.958, 2.941, - 2.924, 2.907, 2.891, 2.875, 2.859, 2.843, 2.828, 2.813, 2.798, 2.783, 2.769, 2.733, 2.699, 2.666, 2.634, 2.603, 2.572, 2.543, 2.514, - 2.486, 2.459, 2.407, 2.357, 2.309, 2.263, 2.22, 2.178, 2.138, 2.099, 2.062, 2.026, 1.992, 1.959, 1.927, 1.896, 3.542e-05, 1.681, 1.570}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.106, - 3.088, 3.07, 3.052, 3.035, 3.018, 3.001, 2.985, 2.969, 2.953, 2.937, 2.922, 2.884, 2.848, 2.812, 2.778, 2.745, 2.713, 2.682, 2.651, - 2.622, 2.593, 2.537, 2.484, 2.434, 2.386, 2.34, 2.295, 2.253, 2.212, 2.173, 2.135, 2.099, 2.064, 2.03, 1.997, 3.542e-05, 1.77, 1.654}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 3.26, 3.24, 3.222, 3.203, 3.185, 3.167, 3.15, 3.132, 3.115, 3.099, 3.082, 3.042, 3.003, 2.966, 2.929, 2.894, 2.86, 2.827, 2.794, - 2.763, 2.732, 2.674, 2.618, 2.564, 2.513, 2.465, 2.418, 2.373, 2.33, 2.289, 2.249, 2.21, 2.173, 2.138, 2.103, 3.542e-05, 1.864, 1.741}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 3.419, 3.399, 3.379, 3.36, 3.341, 3.322, 3.304, 3.286, 3.268, 3.25, 3.207, 3.166, 3.126, 3.087, 3.05, 3.014, 2.978, 2.944, - 2.911, 2.878, 2.816, 2.757, 2.7, 2.646, 2.595, 2.546, 2.498, 2.453, 2.409, 2.367, 2.326, 2.287, 2.25, 2.213, 3.542e-05, 1.961, 1.832}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 3.585, 3.564, 3.543, 3.523, 3.503, 3.483, 3.464, 3.445, 3.426, 3.38, 3.336, 3.294, 3.253, 3.213, 3.174, 3.137, 3.1, - 3.065, 3.031, 2.965, 2.902, 2.842, 2.785, 2.731, 2.679, 2.629, 2.581, 2.535, 2.49, 2.448, 2.406, 2.367, 2.328, 3.542e-05, 2.063, 1.926}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 3.758, 3.735, 3.713, 3.692, 3.671, 3.65, 3.63, 3.61, 3.561, 3.514, 3.469, 3.425, 3.383, 3.342, 3.302, 3.264, - 3.226, 3.19, 3.12, 3.054, 2.99, 2.93, 2.873, 2.818, 2.765, 2.714, 2.665, 2.619, 2.574, 2.53, 2.488, 2.448, 3.542e-05, 2.168, 2.025}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 3.937, 3.913, 3.89, 3.867, 3.845, 3.823, 3.802, 3.75, 3.7, 3.652, 3.605, 3.561, 3.517, 3.475, 3.434, - 3.394, 3.356, 3.282, 3.212, 3.145, 3.081, 3.02, 2.962, 2.907, 2.853, 2.802, 2.752, 2.705, 2.659, 2.615, 2.573, 3.542e-05, 2.278, 2.127}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 4.122, 4.097, 4.073, 4.049, 4.026, 4.003, 3.948, 3.895, 3.843, 3.794, 3.746, 3.7, 3.655, 3.612, - 3.57, 3.529, 3.451, 3.376, 3.306, 3.238, 3.174, 3.113, 3.054, 2.998, 2.944, 2.892, 2.842, 2.794, 2.747, 2.702, 3.542e-05, 2.392, 2.234}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.315, 4.289, 4.263, 4.238, 4.214, 4.155, 4.098, 4.043, 3.991, 3.94, 3.891, 3.843, 3.797, - 3.753, 3.709, 3.627, 3.548, 3.473, 3.402, 3.335, 3.27, 3.208, 3.148, 3.091, 3.037, 2.984, 2.933, 2.884, 2.837, 3.542e-05, 2.511, 2.344}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.515, 4.487, 4.46, 4.434, 4.371, 4.31, 4.252, 4.196, 4.142, 4.09, 4.04, 3.991, - 3.944, 3.898, 3.81, 3.727, 3.648, 3.573, 3.501, 3.433, 3.368, 3.305, 3.245, 3.187, 3.132, 3.079, 3.027, 2.977, 3.542e-05, 2.635, 2.459}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.722, 4.693, 4.665, 4.597, 4.532, 4.47, 4.411, 4.353, 4.298, 4.244, 4.193, - 4.143, 4.094, 4.001, 3.913, 3.83, 3.751, 3.675, 3.603, 3.534, 3.468, 3.405, 3.344, 3.286, 3.23, 3.176, 3.123, 3.542e-05, 2.763, 2.579}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.936, 4.906, 4.833, 4.764, 4.698, 4.635, 4.574, 4.515, 4.458, 4.403, - 4.35, 4.298, 4.2, 4.107, 4.019, 3.935, 3.856, 3.78, 3.707, 3.638, 3.571, 3.507, 3.446, 3.387, 3.33, 3.275, 3.542e-05, 2.896, 2.703}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.159, 5.081, 5.007, 4.936, 4.868, 4.803, 4.741, 4.681, 4.622, - 4.566, 4.512, 4.407, 4.309, 4.216, 4.128, 4.044, 3.964, 3.887, 3.814, 3.744, 3.677, 3.612, 3.55, 3.49, 3.432, 3.542e-05, 3.035, 2.832}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.75, 5.662, 5.579, 5.499, 5.423, 5.35, 5.28, 5.212, - 5.147, 5.084, 4.964, 4.851, 4.744, 4.643, 4.547, 4.456, 4.369, 4.286, 4.206, 4.13, 4.056, 3.986, 3.918, 3.853, 3.542e-05, 3.404, 3.176}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.395, 6.296, 6.202, 6.112, 6.027, 5.945, 5.866, - 5.79, 5.717, 5.579, 5.449, 5.327, 5.211, 5.102, 4.998, 4.898, 4.804, 4.714, 4.627, 4.544, 4.464, 4.388, 4.314, 3.542e-05, 3.808, 3.552}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.098, 6.985, 6.879, 6.779, 6.683, 6.591, - 6.503, 6.418, 6.258, 6.108, 5.968, 5.836, 5.711, 5.593, 5.48, 5.373, 5.27, 5.172, 5.078, 4.988, 4.902, 4.819, 3.542e-05, 4.25, 3.962}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.861, 7.734, 7.615, 7.502, 7.395, - 7.292, 7.193, 7.008, 6.835, 6.674, 6.523, 6.38, 6.245, 6.118, 5.996, 5.88, 5.769, 5.663, 5.561, 5.464, 5.37, 3.542e-05, 4.732, 4.410}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.69, 8.547, 8.413, 8.286, - 8.166, 8.051, 7.835, 7.636, 7.451, 7.278, 7.115, 6.961, 6.816, 6.678, 6.547, 6.421, 6.302, 6.187, 6.078, 5.972, 3.542e-05, 5.257, 4.897}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 9.588, 9.428, 9.277, - 9.135, 9.0, 8.749, 8.519, 8.305, 8.106, 7.92, 7.745, 7.58, 7.423, 7.275, 7.133, 6.998, 6.87, 6.746, 6.628, 3.542e-05, 5.827, 5.425}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.56, 10.38, - 10.21, 10.05, 9.759, 9.491, 9.244, 9.016, 8.803, 8.603, 8.415, 8.238, 8.069, 7.91, 7.758, 7.613, 7.474, 7.341, 3.542e-05, 6.445, 5.998}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 11.62, - 11.41, 11.22, 10.88, 10.56, 10.28, 10.01, 9.769, 9.541, 9.328, 9.126, 8.936, 8.756, 8.584, 8.421, 8.265, 8.116, 3.542e-05, 7.115, 6.618}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 12.75, 12.53, 12.11, 11.75, 11.41, 11.11, 10.83, 10.57, 10.32, 10.1, 9.88, 9.676, 9.483, 9.299, 9.124, 8.957, 3.542e-05, 7.84, 7.288}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 13.99, 13.49, 13.05, 12.67, 12.31, 11.99, 11.69, 11.41, 11.15, 10.91, 10.68, 10.46, 10.25, 10.06, 9.869, 3.542e-05, 8.623, 8.011}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 16.75, 16.12, 15.58, 15.1, 14.66, 14.26, 13.9, 13.56, 13.25, 12.95, 12.67, 12.41, 12.16, 11.93, 3.542e-05, 10.38, 9.628}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 19.97, 19.17, 18.49, 17.89, 17.36, 16.87, 16.43, 16.02, 15.64, 15.28, 14.95, 14.63, 14.34, 3.542e-05, 12.42, 11.5}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 23.71, 22.7, 21.85, 21.1, 20.45, 19.85, 19.31, 18.81, 18.35, 17.93, 17.53, 17.15, 3.542e-05, 14.77, 13.65}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 28.07, 26.78, 25.71, 24.79, 23.97, 23.25, 22.59, 21.99, 21.44, 20.93, 20.45, 3.542e-05, 17.48, 16.12}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 33.16, 31.5, 30.15, 29.0, 28.0, 27.11, 26.31, 25.59, 24.92, 24.31, 3.542e-05, 20.6, 18.94}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 39.13, 36.97, 35.25, 33.82, 32.58, 31.5, 30.53, 29.65, 28.86, 3.542e-05, 24.19, 22.16}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 46.17, 43.33, 41.13, 39.33, 37.8, 36.47, 35.29, 34.24, 3.542e-05, 28.31, 25.84}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 54.54, 50.75, 47.92, 45.65, 43.75, 42.11, 40.68, 3.542e-05, 33.07, 30.03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 64.64, 59.47, 55.78, 52.9, 50.53, 48.51, 3.542e-05, 38.55, 34.81}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 77.05, 69.8, 64.93, 61.24, 58.27, 3.542e-05, 44.92, 40.28}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 92.76, 82.18, 75.63, 70.87, 3.542e-05, 52.35, 46.54}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 113.6, 97.22, 88.27, 3.542e-05, 61.12, 53.76}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 143.9, 115.8, 3.542e-05, 71.6, 62.15}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 201.8, 3.542e-05, 84.38, 71.99}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 148.4, 115.1}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 201.7, 144.2}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 270.9, 177.8}, - }}; - //***************************************************************************** template @@ -4698,8 +2727,10 @@ namespace FluidProperties { // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. - for (int GlycolNum = 1; GlycolNum <= state.dataFluidProps->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluidProps->GlycolData(GlycolNum); + auto &df = state.dataFluidProps; + + for (int GlycolNum = 1; GlycolNum <= df->NumOfGlycols; ++GlycolNum) { + auto &glycol = df->GlycolData(GlycolNum); if (glycol.CpDataPresent) { // check for lowest non-zero value by referencing temp data for (int IndexNum = 1; IndexNum <= glycol.NumCpTempPts; ++IndexNum) { @@ -4800,9 +2831,10 @@ namespace FluidProperties { // for the refrigerant properties. // Most properties requested (e.g., Specific Heat) must be > 0 but the tables may // be set up for symmetry and not be limited to just valid values. + auto &df = state.dataFluidProps; - for (int RefrigNum = 1; RefrigNum <= state.dataFluidProps->NumOfRefrigerants; ++RefrigNum) { - auto &refrig = state.dataFluidProps->RefrigData(RefrigNum); + for (int RefrigNum = 1; RefrigNum <= df->NumOfRefrigerants; ++RefrigNum) { + auto &refrig = df->RefrigData(RefrigNum); for (int IndexNum = 1; IndexNum <= refrig.NumPsPoints; ++IndexNum) { if (refrig.PsValues(IndexNum) <= 0.0) continue; refrig.PsLowPresIndex = IndexNum; @@ -4941,8 +2973,10 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from glycol functions - for (int GlycolNum = 1; GlycolNum <= state.dataFluidProps->NumOfGlycols; ++GlycolNum) { - auto &glycol = state.dataFluidProps->GlycolData(GlycolNum); + auto &df = state.dataFluidProps; + + for (int GlycolNum = 1; GlycolNum <= df->NumOfGlycols; ++GlycolNum) { + auto &glycol = df->GlycolData(GlycolNum); int GlycolIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: @@ -5047,17 +3081,17 @@ namespace FluidProperties { print(state.files.debug, ",{:.2R}", ReturnValue); for (int Loop = 1; Loop <= glycol.NumCpTempPts - 1; ++Loop) { Temperature = glycol.CpTemps(Loop); - ReturnValue = GetSpecificHeatGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = glycol.CpTemps(Loop) + (glycol.CpTemps(Loop + 1) - glycol.CpTemps(Loop)) / 2.0; - ReturnValue = GetSpecificHeatGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } Temperature = glycol.CpTemps(glycol.NumCpTempPts); - ReturnValue = GetSpecificHeatGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); Temperature = glycol.CpTemps(glycol.NumCpTempPts) + incr; - ReturnValue = GetSpecificHeatGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } @@ -5078,17 +3112,17 @@ namespace FluidProperties { print(state.files.debug, ",{:.3R}", ReturnValue); for (int Loop = 1; Loop <= glycol.NumRhoTempPts - 1; ++Loop) { Temperature = glycol.RhoTemps(Loop); - ReturnValue = GetDensityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getDensity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); Temperature = glycol.RhoTemps(Loop) + (glycol.RhoTemps(Loop + 1) - glycol.RhoTemps(Loop)) / 2.0; - ReturnValue = GetDensityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getDensity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); } Temperature = glycol.RhoTemps(glycol.NumRhoTempPts); - ReturnValue = GetDensityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getDensity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); Temperature = glycol.RhoTemps(glycol.NumRhoTempPts) + incr; - ReturnValue = GetDensityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getDensity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}\n", ReturnValue); } @@ -5105,21 +3139,21 @@ namespace FluidProperties { print(state.files.debug, ",{:.2R}\n", glycol.CondTemps(glycol.NumCondTempPts) + incr); print(state.files.debug, "Conductivity:"); Temperature = glycol.CondTemps(1) - incr; - ReturnValue = GetConductivityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); for (int Loop = 1; Loop <= glycol.NumCondTempPts - 1; ++Loop) { Temperature = glycol.CondTemps(Loop); - ReturnValue = GetConductivityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); Temperature = glycol.CondTemps(Loop) + (glycol.CondTemps(Loop + 1) - glycol.CondTemps(Loop)) / 2.0; - ReturnValue = GetConductivityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); } Temperature = glycol.CondTemps(glycol.NumCondTempPts); - ReturnValue = GetConductivityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}", ReturnValue); Temperature = glycol.CondTemps(glycol.NumCondTempPts) + incr; - ReturnValue = GetConductivityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); print(state.files.debug, ",{:.3R}\n", ReturnValue); } @@ -5136,21 +3170,21 @@ namespace FluidProperties { print(state.files.debug, ",{:.2R}\n", glycol.ViscTemps(glycol.NumViscTempPts) + incr); print(state.files.debug, "Viscosity:"); Temperature = glycol.ViscTemps(1) - incr; - ReturnValue = GetViscosityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); print(state.files.debug, ",{:.4R}", ReturnValue); for (int Loop = 1; Loop <= glycol.NumViscTempPts - 1; ++Loop) { Temperature = glycol.ViscTemps(Loop); - ReturnValue = GetViscosityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); print(state.files.debug, ",{:.4R}", ReturnValue); Temperature = glycol.ViscTemps(Loop) + (glycol.ViscTemps(Loop + 1) - glycol.ViscTemps(Loop)) / 2.0; - ReturnValue = GetViscosityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); print(state.files.debug, ",{:.4R}", ReturnValue); } Temperature = glycol.ViscTemps(glycol.NumViscTempPts); - ReturnValue = GetViscosityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); print(state.files.debug, ",{:.4R}", ReturnValue); Temperature = glycol.ViscTemps(glycol.NumViscTempPts) + incr; - ReturnValue = GetViscosityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); print(state.files.debug, ",{:.4R}\n", ReturnValue); } } @@ -5182,221 +3216,181 @@ namespace FluidProperties { Real64 Temperature; // Temperature to drive values Real64 ReturnValue; // Values returned from refrigerant functions - for (int RefrigNum = 1; RefrigNum <= state.dataFluidProps->NumOfRefrigerants; ++RefrigNum) { - int RefrigIndex = 0; // used in routine calls -- value is returned when first 0 + auto &df = state.dataFluidProps; + + for (int RefrigNum = 1; RefrigNum <= df->NumOfRefrigerants; ++RefrigNum) { + auto &refrig = df->RefrigData(RefrigNum); // Lay out the basic values: - if (!state.dataFluidProps->RefrigData(RefrigNum).Name.empty()) { - print(state.files.debug, "Refrigerant={}", state.dataFluidProps->RefrigData(RefrigNum).Name); + if (!refrig.Name.empty()) { + print(state.files.debug, "Refrigerant={}", refrig.Name); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints > 0) { + if (refrig.NumPsPoints > 0) { print(state.files.debug, "Saturation Pressures Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).PsLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).PsHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).PsHighTempIndex); + refrig.PsLowTempValue, + refrig.PsLowTempIndex, + refrig.PsHighTempValue, + refrig.PsHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.PsTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.PsTemps(refrig.NumPsPoints)); print(state.files.debug, "Saturation Pressure:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.PsValues(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsValues(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.PsValues(refrig.NumPsPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumHPoints > 0) { + if (refrig.NumHPoints > 0) { print(state.files.debug, "Enthalpy Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).HfHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfHighTempIndex); + refrig.HfLowTempValue, + refrig.HfLowTempIndex, + refrig.HfHighTempValue, + refrig.HfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HfValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.HfValues(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfValues(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.HfValues(refrig.NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).HfgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).HfgHighTempIndex); + refrig.HfgLowTempValue, + refrig.HfgLowTempIndex, + refrig.HfgHighTempValue, + refrig.HfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HfgValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.HfgValues(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HfgValues(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.HfgValues(refrig.NumHPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints > 0) { + if (refrig.NumCpPoints > 0) { print(state.files.debug, "Specific Heat Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).CpfHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfHighTempIndex); + refrig.CpfLowTempValue, + refrig.CpfLowTempIndex, + refrig.CpfHighTempValue, + refrig.CpfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}\n", state.dataFluidProps->RefrigData(RefrigNum).CpfValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}\n", refrig.CpfValues(Loop)); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).CpfValues(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + print(state.files.debug, ",{:.2R}", refrig.CpfValues(refrig.NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).CpfgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).CpfgHighTempIndex); + refrig.CpfgLowTempValue, + refrig.CpfgLowTempIndex, + refrig.CpfgHighTempValue, + refrig.CpfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpfgValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.CpfgValues(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpfgValues(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.CpfgValues(refrig.NumCpPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (refrig.NumRhoPoints > 0) { print(state.files.debug, "Density Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).RhofHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofHighTempIndex); + refrig.RhofLowTempValue, + refrig.RhofLowTempIndex, + refrig.RhofHighTempValue, + refrig.RhofHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(refrig.NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhofValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.RhofValues(Loop)); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhofValues(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + print(state.files.debug, ",{:.2R}", refrig.RhofValues(refrig.NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofgLowTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofgLowTempIndex, - state.dataFluidProps->RefrigData(RefrigNum).RhofgHighTempValue, - state.dataFluidProps->RefrigData(RefrigNum).RhofgHighTempIndex); + refrig.RhofgLowTempValue, + refrig.RhofgLowTempIndex, + refrig.RhofgHighTempValue, + refrig.RhofgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.RhoTemps(refrig.NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhofgValues(Loop)); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.RhofgValues(Loop)); } - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhofgValues(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.RhofgValues(refrig.NumRhoPoints)); } - if (state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts > 0 && state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts > 0) { - print(state.files.debug, - "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", - state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts, - state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts); + if (refrig.NumSuperTempPts > 0 && refrig.NumSuperPressPts > 0) { + print(state.files.debug, "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", + refrig.NumSuperTempPts, + refrig.NumSuperPressPts); print(state.files.debug, "Superheated Temperatures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumSuperTempPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", refrig.SHTemps(Loop)); } - print(state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).SHTemps(state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig.SHTemps(refrig.NumSuperTempPts)); print(state.files.debug, "Superheated Pressures:"); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= refrig.NumSuperPressPts - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", refrig.SHPress(Loop)); } - print(state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).SHPress(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts)); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + print(state.files.debug, ",{:.3R}\n", refrig.SHPress(refrig.NumSuperPressPts)); + for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig.SHPress(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= refrig.NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig.HshValues(Loop, Loop1)); } - print(state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop, state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig.HshValues(Loop, refrig.NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHPress(Loop)); + for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig.SHPress(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= refrig.NumSuperTempPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig.RhoshValues(Loop, Loop1)); } - print(state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop, state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig.RhoshValues(Loop, refrig.NumSuperTempPts)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig.SHTemps(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).HshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= refrig.NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig.HshValues(Loop1, Loop)); } - print(state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HshValues(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + print(state.files.debug, ",{:.3R}\n", refrig.HshValues(refrig.NumSuperPressPts, Loop)); } - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, state.dataFluidProps->RefrigData(RefrigNum).SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig.NumSuperTempPts; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig.SHTemps(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= refrig.NumSuperPressPts - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig.RhoshValues(Loop1, Loop)); } - print( - state.files.debug, - ",{:.3R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoshValues(state.dataFluidProps->RefrigData(RefrigNum).NumSuperPressPts, Loop)); + print(state.files.debug, ",{:.3R}\n", refrig.RhoshValues(refrig.NumSuperPressPts, Loop)); } } @@ -5405,184 +3399,127 @@ namespace FluidProperties { // ============================================ // ========= Pressure from Temperatures - print(state.files.debug, "Refrigerant={} **** Results ****\n", state.dataFluidProps->RefrigData(RefrigNum).Name); - if (state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints > 0) { + print(state.files.debug, "Refrigerant={} **** Results ****\n", refrig.Name); + if (refrig.NumPsPoints > 0) { print(state.files.debug, "Pressure Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)) / - 2.0; + print(state.files.debug, ",{:.2R}", refrig.PsTemps(1) - incr); + for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.PsTemps(Loop)); + Temperature = refrig.PsTemps(Loop) + (refrig.PsTemps(Loop + 1) - refrig.PsTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints)); - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig.PsTemps(refrig.NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.PsTemps(refrig.NumPsPoints) + incr); print(state.files.debug, "Saturated Pressures:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(1) - incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = refrig.PsTemps(1) - incr; + ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop); - ReturnValue = - GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { + Temperature = refrig.PsTemps(Loop); + ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).PsTemps(Loop)) / - 2.0; - ReturnValue = - GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = refrig.PsTemps(Loop) + (refrig.PsTemps(Loop + 1) - refrig.PsTemps(Loop)) / 2.0; + ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints); - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = refrig.PsTemps(refrig.NumPsPoints); + ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).PsTemps(state.dataFluidProps->RefrigData(RefrigNum).NumPsPoints) + incr; - ReturnValue = GetSatPressureRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, RefrigIndex, RoutineName); + Temperature = refrig.PsTemps(refrig.NumPsPoints) + incr; + ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Enthalpy from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumHPoints > 0) { + if (refrig.NumHPoints > 0) { print(state.files.debug, "Enthalpy Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)) / - 2.0; + print(state.files.debug, ",{:.2R}", refrig.HTemps(1) - incr); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); + Temperature = refrig.HTemps(Loop) + (refrig.HTemps(Loop + 1) - refrig.HTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints)); - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig.HTemps(refrig.NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints) + incr); print(state.files.debug, "Saturated Enthalpy:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(1) - incr; - ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.HTemps(1) - incr; + ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumHPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop); - ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { + Temperature = refrig.HTemps(Loop); + ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).HTemps(Loop)) / - 2.0; - ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.HTemps(Loop) + (refrig.HTemps(Loop + 1) - refrig.HTemps(Loop)) / 2.0; + ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints); - ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.HTemps(refrig.NumHPoints); + ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).HTemps(state.dataFluidProps->RefrigData(RefrigNum).NumHPoints) + incr; - ReturnValue = - GetSatEnthalpyRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.HTemps(refrig.NumHPoints) + incr; + ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Specific Heat from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints > 0) { + if (refrig.NumCpPoints > 0) { print(state.files.debug, "Specific Heat Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)) / - 2.0; + print(state.files.debug, ",{:.2R}", refrig.CpTemps(1) - incr); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); + Temperature = refrig.CpTemps(Loop) + (refrig.CpTemps(Loop + 1) - refrig.CpTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints)); - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig.CpTemps(refrig.NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints) + incr); print(state.files.debug, "Saturated Specific Heat:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(1) - incr; - ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.CpTemps(1) - incr; + ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop); - ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { + Temperature = refrig.CpTemps(Loop); + ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop) + - (state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop + 1) - state.dataFluidProps->RefrigData(RefrigNum).CpTemps(Loop)) / - 2.0; - ReturnValue = GetSatSpecificHeatRefrig( - state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.CpTemps(Loop) + (refrig.CpTemps(Loop + 1) - refrig.CpTemps(Loop)) / 2.0; + ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints); - ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.CpTemps(refrig.NumCpPoints); + ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).CpTemps(state.dataFluidProps->RefrigData(RefrigNum).NumCpPoints) + incr; - ReturnValue = - GetSatSpecificHeatRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.CpTemps(refrig.NumCpPoints) + incr; + ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Density from Temperatures - if (state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints > 0) { + if (refrig.NumRhoPoints > 0) { print(state.files.debug, "Density Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(1) - incr); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)) / - 2.0; + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(1) - incr); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); + Temperature = refrig.RhoTemps(Loop) + (refrig.RhoTemps(Loop + 1) - refrig.RhoTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, - ",{:.2R}", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints)); - print(state.files.debug, - ",{:.2R}\n", - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig.RhoTemps(refrig.NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig.RhoTemps(refrig.NumRhoPoints) + incr); print(state.files.debug, "Saturated Density:"); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(1) - incr; - ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.RhoTemps(1) - incr; + ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints - 1; ++Loop) { - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop); - ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { + Temperature = refrig.RhoTemps(Loop); + ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop) + (state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop + 1) - - state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(Loop)) / - 2.0; - ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.RhoTemps(Loop) + (refrig.RhoTemps(Loop + 1) - refrig.RhoTemps(Loop)) / 2.0; + ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints); - ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.RhoTemps(refrig.NumRhoPoints); + ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = state.dataFluidProps->RefrigData(RefrigNum).RhoTemps(state.dataFluidProps->RefrigData(RefrigNum).NumRhoPoints) + incr; - ReturnValue = - GetSatDensityRefrig(state, state.dataFluidProps->RefrigData(RefrigNum).Name, Temperature, Quality, RefrigIndex, RoutineName); + Temperature = refrig.RhoTemps(refrig.NumRhoPoints) + incr; + ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } } @@ -5590,7 +3527,7 @@ namespace FluidProperties { //***************************************************************************** - Real64 RefrigerantData::getSatPressure(EnergyPlusData &state, + Real64 RefrigProps::getSatPressure(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) @@ -5608,13 +3545,15 @@ namespace FluidProperties { // and linearly interpolates the corresponding saturation pressure values. // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "RefrigerantData::getSatPressure"; + static constexpr std::string_view routineName = "RefrigProps::getSatPressure"; Real64 ReturnValue = 0; bool ErrorFlag = false; // error flag for current call int LoTempIndex = FindArrayIndex(Temperature, this->PsTemps, this->PsLowTempIndex, this->PsHighTempIndex); + auto &df = state.dataFluidProps; + // check for out of data bounds problems if (LoTempIndex == 0) { ReturnValue = this->PsValues(this->PsLowTempIndex); @@ -5631,14 +3570,13 @@ namespace FluidProperties { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - ++refrigError.SatTempErrCount; + ++this->errors[(int)RefrigError::SatTemp].count; // send warning - if (refrigError.SatTempErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatTemp].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -5650,8 +3588,8 @@ namespace FluidProperties { } ShowRecurringSevereErrorAtEnd(state, format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", - routineName, refrigError.Name), - refrigError.SatTempErrIndex, + routineName, this->Name), + this->errors[(int)RefrigError::SatTemp].index, Temperature, Temperature, _, @@ -5663,7 +3601,7 @@ namespace FluidProperties { } Real64 GetSatPressureRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input int &RefrigIndex, // Index to Refrigerant Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -5680,40 +3618,24 @@ namespace FluidProperties { // METHODOLOGY EMPLOYED: // Calls FindArrayIndex to find indices either side of requested temperature // and linearly interpolates the corresponding saturation pressure values. + auto &df = state.dataFluidProps; - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int HiTempIndex; // index value of next highest Temperature from table - int LoTempIndex; // index value of next lowest Temperature from table - Real64 TempInterpRatio; // ratio to interpolate in temperature domain - - int RefrigNum = 0; // index for refrigerant under consideration - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); - } - - bool ErrorFlag = false; - - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatPressureRefrig", "properties", CalledFrom); + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSatPressure(state, Temperature, CalledFrom); + return df->RefrigData(RefrigIndex).getSatPressure(state, Temperature, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSatTemperature(EnergyPlusData &state, - Real64 const Pressure, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 RefrigProps::getSatTemperature(EnergyPlusData &state, + Real64 const Pressure, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -5732,39 +3654,39 @@ namespace FluidProperties { Real64 ReturnValue; // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "RefrigerantData::getSatTemperature"; + static constexpr std::string_view routineName = "RefrigProps::getSatTemperature"; // FUNCTION LOCAL VARIABLE DECLARATIONS: bool ErrorFlag; // error flag for current call + auto &df = state.dataFluidProps; + // get the array indices int LoPresIndex = FindArrayIndex(Pressure, this->PsValues, this->PsLowPresIndex, this->PsHighPresIndex); - int HiPresIndex = LoPresIndex + 1; // check for out of data bounds problems if (LoPresIndex == 0) { ReturnValue = this->PsTemps(this->PsLowPresIndex); ErrorFlag = true; - } else if (HiPresIndex > this->PsHighPresIndex) { + } else if (LoPresIndex+1 > this->PsHighPresIndex) { ReturnValue = this->PsTemps(this->PsHighPresIndex); ErrorFlag = true; } else { // find interpolation ratio w.r.t temperature - Real64 PresInterpRatio = (Pressure - this->PsValues(LoPresIndex)) / (this->PsValues(HiPresIndex) - this->PsValues(LoPresIndex)); + Real64 PresInterpRatio = (Pressure - this->PsValues(LoPresIndex)) / (this->PsValues(LoPresIndex+1) - this->PsValues(LoPresIndex)); // apply final linear interpolation - ReturnValue = this->PsTemps(LoPresIndex) + PresInterpRatio * (this->PsTemps(HiPresIndex) - this->PsTemps(LoPresIndex)); + ReturnValue = this->PsTemps(LoPresIndex) + PresInterpRatio * (this->PsTemps(LoPresIndex+1) - this->PsTemps(LoPresIndex)); } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - ++refrigError.SatPressErrCount; + ++this->errors[(int)RefrigError::SatPress].count; // send warning - if (refrigError.SatPressErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatPress].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.0R},{:.0R}]", CalledFrom, @@ -5775,8 +3697,8 @@ namespace FluidProperties { ShowContinueErrorTimeStamp(state, ""); } ShowRecurringSevereErrorAtEnd(state, - format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, refrigError.Name), - refrigError.SatPressErrIndex, + format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), + this->errors[(int)RefrigError::SatPress].index, Pressure, Pressure, _, @@ -5787,7 +3709,7 @@ namespace FluidProperties { } Real64 GetSatTemperatureRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Pressure, // actual temperature given as input int &RefrigIndex, // Index to Refrigerant Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -5804,44 +3726,22 @@ namespace FluidProperties { // METHODOLOGY EMPLOYED: // Calls FindArrayIndex to find indices either side of requested pressure // and linearly interpolates the corresponding saturation temperature values. + auto &df = state.dataFluidProps; - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int HiPresIndex; // index value of next highest Temperature from table - int LoPresIndex; // index value of next lowest Temperature from table - Real64 PresInterpRatio; // ratio to interpolate in temperature domain - - int RefrigNum = 0; // index for refrigerant under consideration - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatTemperatureRefrig", "properties", CalledFrom); - } - - bool ErrorFlag = false; - - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, - RefrigNum, - true, - Refrigerant, - "GetSatTemperatureRefrig", - "properties", - CalledFrom); + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSatTemperature(state, Pressure, CalledFrom); + return df->RefrigData(RefrigIndex).getSatTemperature(state, Pressure, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSatEnthalpy(EnergyPlusData &state, + Real64 RefrigProps::getSatEnthalpy(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -5868,7 +3768,7 @@ namespace FluidProperties { } Real64 GetSatEnthalpyRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -5890,40 +3790,22 @@ namespace FluidProperties { // Calls GetInterpolatedSatProp to linearly interpolate between the saturated // liquid and vapour enthalpies according to the given quality. - // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatEnthalpyRefrig"); - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); - } - - if ((Quality < 0.0) || (Quality > 1.0)) { - ShowSevereError(state, fmt::format("{}: Refrigerant \"{}\", invalid quality, called from {}", RoutineName, Refrigerant, CalledFrom)); - ShowContinueError(state, format("Saturated refrigerant quality must be between 0 and 1, entered value=[{:.4R}].", Quality)); - ShowFatalError(state, "Program terminates due to preceding condition."); - } - - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + auto &df = state.dataFluidProps; + + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - - return state.dataFluidProps->RefrigData(RefrigNum).getSatEnthalpy(state, Temperature, Quality, CalledFrom); + return df->RefrigData(RefrigIndex).getSatEnthalpy(state, Temperature, Quality, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSatDensity(EnergyPlusData &state, + Real64 RefrigProps::getSatDensity(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -5948,7 +3830,9 @@ namespace FluidProperties { Real64 ReturnValue; // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "RefrigerantData::getSatDensity"; + static constexpr std::string_view routineName = "RefrigProps::getSatDensity"; + + auto &df = state.dataFluidProps; if ((Quality < 0.0) || (Quality > 1.0)) { ShowSevereError(state, fmt::format("{}Refrigerant \"{}\", invalid quality, called from {}", routineName, this->Name, CalledFrom)); @@ -5997,14 +3881,13 @@ namespace FluidProperties { } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - ++refrigError.SatTempDensityErrCount; + ++this->errors[(int)RefrigError::SatTempDensity].count; // send warning - if (refrigError.SatTempDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatTempDensity].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -6015,8 +3898,8 @@ namespace FluidProperties { ShowContinueErrorTimeStamp(state, ""); } ShowRecurringSevereErrorAtEnd(state, - format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, refrigError.Name), - refrigError.SatTempDensityErrIndex, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), + this->errors[(int)RefrigError::SatTempDensity].index, Temperature, Temperature, _, @@ -6027,7 +3910,7 @@ namespace FluidProperties { } Real64 GetSatDensityRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -6049,37 +3932,22 @@ namespace FluidProperties { // Calls GetInterpolatedSatProp to linearly interpolate between the saturated // liquid and vapour densities according to the given quality. - // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatDensityRefrig: "); - - // error counters and dummy string - - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatDensityRefrig", "properties", CalledFrom); + auto &df = state.dataFluidProps; + + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSatDensity(state, Temperature, Quality, CalledFrom); + return df->RefrigData(RefrigIndex).getSatDensity(state, Temperature, Quality, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSatSpecificHeat(EnergyPlusData &state, + Real64 RefrigProps::getSatSpecificHeat(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -6101,7 +3969,7 @@ namespace FluidProperties { // liquid and vapour specific heats according to the given quality. // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "RefrigerantData::getSatSpecificHeat"; + static constexpr std::string_view routineName = "RefrigProps::getSatSpecificHeat"; if ((Quality < 0.0) || (Quality > 1.0)) { ShowSevereError(state, fmt::format("{}: Refrigerant \"{}\", invalid quality, called from {}", routineName, this->Name, CalledFrom)); @@ -6123,7 +3991,7 @@ namespace FluidProperties { } Real64 GetSatSpecificHeatRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Quality, // actual quality given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -6145,41 +4013,22 @@ namespace FluidProperties { // Calls GetInterpolatedSatProp to linearly interpolate between the saturated // liquid and vapour specific heats according to the given quality. - // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view RoutineName("GetSatSpecificHeatRefrig: "); - - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSatSpecificHeatRefrig", "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, - RefrigNum, - true, - Refrigerant, - "GetSatSpecificHeatRefrig", - "properties", - CalledFrom); + auto &df = state.dataFluidProps; + + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSatSpecificHeat(state, Temperature, Quality, CalledFrom); + return df->RefrigData(RefrigIndex).getSatSpecificHeat(state, Temperature, Quality, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSupHeatEnthalpy(EnergyPlusData &state, + Real64 RefrigProps::getSupHeatEnthalpy(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Pressure, // actual pressure given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -6212,8 +4061,10 @@ namespace FluidProperties { Real64 ReturnValue; // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "RefrigerantData::getSupHeatEnthalpy"; + static constexpr std::string_view routineName = "RefrigProps::getSupHeatEnthalpy"; + auto &df = state.dataFluidProps; + Real64 TempInterpRatio; Real64 PressInterpRatio; @@ -6299,20 +4150,19 @@ namespace FluidProperties { // inside the saturation dome. Best thing we can do is return saturation value if ((this->HshValues(LoPressIndex, TempIndex) <= 0.0) && (this->HshValues(HiPressIndex, TempIndex) <= 0.0) && (this->HshValues(LoPressIndex, HiTempIndex) <= 0.0) && (this->HshValues(HiPressIndex, HiTempIndex) <= 0.0)) { - ++state.dataFluidProps->SatErrCountGetSupHeatEnthalpyRefrig; + ++df->SatErrCountGetSupHeatEnthalpyRefrig; // set return value ReturnValue = this->getSatEnthalpy(state, Temperature, 1.0, fmt::format("{}:{}", routineName, CalledFrom)); // send warning if (!state.dataGlobal->WarmupFlag) { - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - refrigError.SatSupEnthalpyErrCount += state.dataFluidProps->SatErrCountGetSupHeatEnthalpyRefrig; + this->errors[(int)RefrigError::SatSupEnthalpy].count += df->SatErrCountGetSupHeatEnthalpyRefrig; // send warning - if (refrigError.SatTempDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatTempDensity].count <= df->RefrigErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] is saturated at the given conditions, saturated enthalpy at given temperature returned. **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); @@ -6320,8 +4170,8 @@ namespace FluidProperties { ShowContinueErrorTimeStamp(state, ""); } ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, refrigError.Name), - refrigError.SatSupEnthalpyErrIndex, + format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpy].index, Temperature, Temperature, _, @@ -6335,13 +4185,12 @@ namespace FluidProperties { // some checks... if (ErrCount > 0) { // send temp range error if flagged - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - refrigError.SatSupEnthalpyTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && refrigError.SatSupEnthalpyTempErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupEnthalpy].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupEnthalpyTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } @@ -6349,8 +4198,8 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", routineName, - refrigError.Name), - refrigError.SatSupEnthalpyTempErrIndex, + this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, Temperature, Temperature, _, @@ -6359,19 +4208,19 @@ namespace FluidProperties { } // send pressure range error if flagged - refrigError.SatSupEnthalpyPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && refrigError.SatSupEnthalpyPresErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupEnthalpyPress].count += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupEnthalpyPress].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, refrigError.Name), - refrigError.SatSupEnthalpyPresErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyPress].index, Pressure, Pressure, _, @@ -6385,7 +4234,7 @@ namespace FluidProperties { } Real64 GetSupHeatEnthalpyRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Pressure, // actual pressure given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -6416,35 +4265,22 @@ namespace FluidProperties { // is not clearly in the bounds of the superheated data. // FUNCTION PARAMETER DEFINITIONS: - static constexpr std::string_view routineName = "GetSupHeatEnthalpyRefrig"; - - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, routineName, "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature and pressure are within the temperature and - // pressure arrays, respectively - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, routineName, "properties", CalledFrom); + auto &df = state.dataFluidProps; + + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - - return state.dataFluidProps->RefrigData(RefrigNum).getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); + + return df->RefrigData(RefrigIndex).getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSupHeatPressure(EnergyPlusData &state, + Real64 RefrigProps::getSupHeatPressure(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Enthalpy, // actual enthalpy given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -6478,8 +4314,10 @@ namespace FluidProperties { // FUNCTION PARAMETERS: // the enthalpy calculated from the pressure found static constexpr std::string_view routineName = "GetSupHeatPressureRefrig"; - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: + + auto &df = state.dataFluidProps; + + // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 EnthalpyCheck; // recalculates enthalpy based on calculated pressure Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature Real64 EnthalpyLow; // Enthalpy value at interpolated pressure and low temperature @@ -6619,15 +4457,14 @@ namespace FluidProperties { // ** make error checks ** if (ErrCount > 0) { // send near saturation warning if flagged - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - refrigError.SatSupPressureErrCount += CurSatErrCount; + this->errors[(int)RefrigError::SatSupPress].count += CurSatErrCount; // send warning - if (refrigError.SatSupPressureErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatSupPress].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " "temperature returned. **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant Enthalpy = {:.3R}", Enthalpy)); @@ -6636,8 +4473,8 @@ namespace FluidProperties { } if (CurSatErrCount > 0) { ShowRecurringSevereErrorAtEnd(state, - format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, refrigError.Name), - refrigError.SatSupPressureErrIndex, + format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPress].index, ReturnValue, ReturnValue, _, @@ -6646,19 +4483,19 @@ namespace FluidProperties { } // send temp range error if flagged - refrigError.SatSupPressureTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && refrigError.SatSupPressureTempErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupPressTemp].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupPressTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", routineName, refrigError.Name), - refrigError.SatSupPressureTempErrIndex, + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressTemp].index, Temperature, Temperature, _, @@ -6667,19 +4504,19 @@ namespace FluidProperties { } // send enthalpy range error if flagged - refrigError.SatSupPressureEnthErrCount += CurEnthalpyRangeErrCount; - if (CurEnthalpyRangeErrCount > 0 && refrigError.SatSupPressureEnthErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupPressEnthalpy].count += CurEnthalpyRangeErrCount; + if (CurEnthalpyRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupPressEnthalpy].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurEnthalpyRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant pressure: values capped **", routineName, refrigError.Name), - refrigError.SatSupPressureEnthErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant pressure: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressEnthalpy].index, Enthalpy, Enthalpy, _, @@ -6694,7 +4531,7 @@ namespace FluidProperties { Real64 GetSupHeatPressureRefrig(EnergyPlusData &state, - std::string const &Refrigerant, // carries in substance name + std::string const &refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Enthalpy, // actual enthalpy given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -6722,39 +4559,22 @@ namespace FluidProperties { // and warnings given. For enthlpys lower than the saturated vapour value at the // given temperature result in the saturation pressure being returned (calls to // GetSatEnthalpy and GetSatPressure are made.) + auto &df = state.dataFluidProps; - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, - RefrigNum, - true, - Refrigerant, - "GetSupHeatPressureRefrig", - "properties", - CalledFrom); + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSupHeatPressure(state, Temperature, Enthalpy, CalledFrom); + return df->RefrigData(RefrigIndex).getSupHeatPressure(state, Temperature, Enthalpy, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSupHeatTemp(EnergyPlusData &state, + Real64 RefrigProps::getSupHeatTemp(EnergyPlusData &state, Real64 const Pressure, // actual pressure given as input Real64 const Enthalpy, // actual enthalpy given as input Real64 TempLow, // lower bound of temperature in the iteration @@ -6787,8 +4607,6 @@ namespace FluidProperties { Real64 RefTSat; // Saturated temperature of the refrigerant. Used to check whether the refrigernat is in the superheat area Real64 Temp; // Temperature of the superheated refrigerant at the given enthalpy and pressure - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - // check temperature data range and attempt to cap if necessary RefTHigh = this->PsHighTempValue; RefTSat = this->getSatTemperature(state, Pressure, fmt::format("{}:{}", routineName, CalledFrom)); @@ -6797,7 +4615,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}: Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; @@ -6806,7 +4624,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}: Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempUp = RefTHigh; @@ -6815,7 +4633,7 @@ namespace FluidProperties { ShowWarningMessage(state, format("{}Refrigerant [{}] temperature lower bound is out of range for superheated refrigerant: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); TempLow = RefTSat; @@ -6856,7 +4674,7 @@ namespace FluidProperties { } Real64 GetSupHeatTempRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Pressure, // actual pressure given as input Real64 const Enthalpy, // actual enthalpy given as input Real64 TempLow, // lower bound of temperature in the iteration @@ -6875,39 +4693,22 @@ namespace FluidProperties { // METHODOLOGY EMPLOYED: // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. - - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, "GetSupHeatPressureRefrig", "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature is within the temperature array - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors(state, - state.dataFluidProps->NumOfRefrigerants, - RefrigNum, - true, - Refrigerant, - "GetSupHeatPressureRefrig", - "properties", - CalledFrom); + auto &df = state.dataFluidProps; + + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); + return df->RefrigData(RefrigIndex).getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); } //***************************************************************************** - Real64 RefrigerantData::getSupHeatDensity(EnergyPlusData &state, + Real64 RefrigProps::getSupHeatDensity(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input Real64 const Pressure, // actual pressure given as input std::string_view const CalledFrom // routine this function was called from (error messages) @@ -6939,8 +4740,10 @@ namespace FluidProperties { // Return value Real64 ReturnValue; + auto &df = state.dataFluidProps; + // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "RefrigerantData::getSupHeatDensity"; + static constexpr std::string_view routineName = "RefrigProps::getSupHeatDensity"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 TempInterpRatio; // Interpolation ratio w.r.t temperature @@ -7033,28 +4836,26 @@ namespace FluidProperties { // interpolate w.r.t. temperature ReturnValue = TempInterpRatio * DensityHigh + (1.0 - TempInterpRatio) * DensityLow; } else { // All data is at zero: we are completely inside the saturation dome. Best thing we can do is return saturation value - - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - ++state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig; + ++df->SatErrCountGetSupHeatDensityRefrig; // send warning - refrigError.SatSupDensityErrCount += state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig; + this->errors[(int)RefrigError::SatSupDensity].count += df->SatErrCountGetSupHeatDensityRefrig; // send warning - if (refrigError.SatSupDensityErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (this->errors[(int)RefrigError::SatSupDensity].count <= df->RefrigErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] is saturated at the given conditions, saturated density at given temperature returned. **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant pressure = {:.0R}", Pressure)); ShowContinueError(state, format("Returned Density value = {:.3R}", saturated_density)); ShowContinueErrorTimeStamp(state, ""); } - if (state.dataFluidProps->SatErrCountGetSupHeatDensityRefrig > 0) { + if (df->SatErrCountGetSupHeatDensityRefrig > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, refrigError.Name), - refrigError.SatSupEnthalpyErrIndex, + format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpy].index, Temperature, Temperature, _, @@ -7068,21 +4869,20 @@ namespace FluidProperties { // some checks... if (ErrCount > 0) { // send temp range error if flagged - auto &refrigError = state.dataFluidProps->RefrigErrorTracking(this->Num); - refrigError.SatSupDensityTempErrCount += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && refrigError.SatSupDensityTempErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupDensityTemp].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupDensityTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage( state, format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurTempRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", routineName, refrigError.Name), - refrigError.SatSupDensityTempErrIndex, + format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityTemp].index, Temperature, Temperature, _, @@ -7091,19 +4891,19 @@ namespace FluidProperties { } // send pressure range error if flagged - refrigError.SatSupDensityPresErrCount += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && refrigError.SatSupDensityPresErrCount <= state.dataFluidProps->RefrigerantErrorLimitTest) { + this->errors[(int)RefrigError::SatSupDensityPress].count += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupDensityPress].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", routineName, - refrigError.Name)); + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } if (CurPresRangeErrCount > 0) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", routineName, refrigError.Name), - refrigError.SatSupDensityPresErrIndex, + format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityPress].index, Pressure, Pressure, _, @@ -7117,7 +4917,7 @@ namespace FluidProperties { } Real64 GetSupHeatDensityRefrig(EnergyPlusData &state, - std::string_view const Refrigerant, // carries in substance name + std::string_view const refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Pressure, // actual pressure given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -7147,40 +4947,26 @@ namespace FluidProperties { // have the pressure/temperature capped. Warnings are given if the point // is not clearly in the bounds of the superheated data. - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName("GetSupHeatDensityRefrig"); - - int RefrigNum = 0; - if (state.dataFluidProps->NumOfRefrigerants == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); - } - - // Find which refrigerant (index) is being requested and then determine - // where the temperature and pressure are within the temperature and - // pressure arrays, respectively - if (RefrigIndex > 0) { - RefrigNum = RefrigIndex; - } else { - // Find which refrigerant (index) is being requested - RefrigNum = GetRefrigNum(state, Refrigerant); - if (RefrigNum == 0) { - ReportFatalRefrigerantErrors( - state, state.dataFluidProps->NumOfRefrigerants, RefrigNum, true, Refrigerant, RoutineName, "properties", CalledFrom); + auto &df = state.dataFluidProps; + if (RefrigIndex == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - RefrigIndex = RefrigNum; } - return state.dataFluidProps->RefrigData(RefrigNum).getSupHeatDensity(state, Temperature, Pressure, CalledFrom); + return df->RefrigData(RefrigIndex).getSupHeatDensity(state, Temperature, Pressure, CalledFrom); } //***************************************************************************** #ifdef EP_cache_GlycolSpecificHeat - Real64 GlycolData::getSpecificHeat(EnergyPlusData &state, + Real64 GlycolProps::getSpecificHeat(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) { + auto &df = state.dataFluidProps; std::uint64_t constexpr Grid_Shift = 64 - 12 - t_sh_precision_bits; double const t(Temperature + 1000 * this->Num); @@ -7193,7 +4979,7 @@ namespace FluidProperties { DISABLE_WARNING_POP std::uint64_t const hash(T_tag & t_sh_cache_mask); - auto &cTsh(state.dataFluidProps->cached_t_sh[hash]); + auto &cTsh(df->cached_t_sh[hash]); if (cTsh.iT != T_tag) { cTsh.iT = T_tag; @@ -7203,12 +4989,12 @@ namespace FluidProperties { return cTsh.sh; // saturation pressure {Pascals} } - Real64 GlycolData::getSpecificHeat_raw(EnergyPlusData &state, + Real64 GlycolProps::getSpecificHeat_raw(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) #else - Real64 GlycolData::getSpecificHeat(EnergyPlusData &state, + Real64 GlycolProps::getSpecificHeat(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) @@ -7234,27 +5020,23 @@ namespace FluidProperties { // all temperature lists are entered in ascending order. // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "GlycolData::getSpecificHeat"; + static constexpr std::string_view routineName = "GlycolProps::getSpecificHeat"; - auto &glycolError = state.dataFluidProps->GlycolErrorTracking(this->Num); + auto &df = state.dataFluidProps; // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!this->CpDataPresent) { - ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, - this->Num, - this->CpDataPresent, - this->Name, - "GetSpecificHeatGlycol", - "specific heat", - CalledFrom); + ShowSevereError(state, format("{}: specific heat data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } // Now determine the value of specific heat using interpolation if (Temperature < this->CpLowTempValue) { // Temperature too low + if (!state.dataGlobal->WarmupFlag) { - state.dataFluidProps->LowTempLimitErrGetSpecificHeatGlycol_raw = ++glycolError.SpecHeatLowErrCount; - if (state.dataFluidProps->LowTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProps->GlycolErrorLimitTest) { + df->glycolErrorLimits[(int)GlycolError::SpecHeatLow] = ++this->errors[(int)GlycolError::SpecHeatLow].count; + if (df->glycolErrorLimits[(int)GlycolError::SpecHeatLow] <= df->GlycolErrorLimitTest) { ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", routineName, @@ -7269,7 +5051,7 @@ namespace FluidProperties { } ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), - glycolError.SpecHeatLowErrIndex, + this->errors[(int)GlycolError::SpecHeatLow].index, Temperature, Temperature, _, @@ -7280,8 +5062,8 @@ namespace FluidProperties { } else if (Temperature > this->CpHighTempValue) { // Temperature too high if (!state.dataGlobal->WarmupFlag) { - state.dataFluidProps->HighTempLimitErrGetSpecificHeatGlycol_raw = ++glycolError.SpecHeatHighErrCount; - if (state.dataFluidProps->HighTempLimitErrGetSpecificHeatGlycol_raw <= state.dataFluidProps->GlycolErrorLimitTest) { + df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] = ++this->errors[(int)GlycolError::SpecHeatHigh].count; + if (df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] <= df->GlycolErrorLimitTest) { ShowWarningMessage( state, format("{}: Temperature is out of range (too high) for fluid [{}] specific heat **", routineName, this->Name)); ShowContinueError(state, @@ -7294,7 +5076,7 @@ namespace FluidProperties { } ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), - glycolError.SpecHeatHighErrIndex, + this->errors[(int)GlycolError::SpecHeatHigh].index, Temperature, Temperature, _, @@ -7324,7 +5106,7 @@ namespace FluidProperties { } Real64 GetSpecificHeatGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name + std::string_view const glycolName, // carries in substance name Real64 const Temperature, // actual temperature given as input int &GlycolIndex, // Index to Glycol Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -7349,40 +5131,22 @@ namespace FluidProperties { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "GetDensityGlycol"; - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - - // If no glycols, no fluid properties can be evaluated - int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); - - // If glycol index has not yet been found for this fluid, find its value now - if (GlycolIndex > 0) { - GlycolNum = GlycolIndex; - } else { // Find which glycol (index) is being requested - GlycolNum = GetGlycolNum(state, Glycol); - if (GlycolNum == 0) { - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetSpecificHeatGlycol", "specific heat", CalledFrom); + auto &df = state.dataFluidProps; + + if (GlycolIndex == 0) { + if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { + ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - GlycolIndex = GlycolNum; } - return state.dataFluidProps->GlycolData(GlycolIndex).getSpecificHeat(state, Temperature, CalledFrom); + return df->GlycolData(GlycolIndex).getSpecificHeat(state, Temperature, CalledFrom); } //***************************************************************************** - Real64 GlycolData::getDensity(EnergyPlusData &state, + Real64 GlycolProps::getDensity(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) @@ -7410,30 +5174,26 @@ namespace FluidProperties { Real64 ReturnValue; // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "GetDensityGlycol"; + static constexpr std::string_view routineName = "GlycolProps::getDensity"; + auto &df = state.dataFluidProps; + // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; + GlycolError error = GlycolError::Invalid; // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!this->RhoDataPresent) { - ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, - this->Num, - this->RhoDataPresent, - this->Name, - "GetDensityGlycol", - "density", - CalledFrom); + ShowSevereError(state, format("{}: density data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } // Now determine the value of specific heat using interpolation if (Temperature < this->RhoLowTempValue) { // Temperature too low - LowErrorThisTime = true; + error = GlycolError::DensityLow; ReturnValue = this->RhoValues(this->RhoLowTempIndex); } else if (Temperature > this->RhoHighTempValue) { // Temperature too high - HighErrorThisTime = true; + error = GlycolError::DensityHigh; ReturnValue = this->RhoValues(this->RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPts); @@ -7443,21 +5203,13 @@ namespace FluidProperties { // Error handling if (!state.dataGlobal->WarmupFlag) { - auto &glycolError = state.dataFluidProps->GlycolErrorTracking(this->Num); - if (LowErrorThisTime) { - ++glycolError.DensityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetDensityGlycol = glycolError.DensityLowErrCount; - } - if (HighErrorThisTime) { - ++glycolError.DensityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetDensityGlycol = glycolError.DensityHighErrCount; + if (error != GlycolError::Invalid) { + df->glycolErrorLimits[(int)error] = this->errors[(int)error].count; } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetDensityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}Temperature is out of range (too low) for fluid [{}] density **", - routineName, - this->Name)); + if ((error == GlycolError::DensityLow) && + (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest)) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] density **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -7466,10 +5218,10 @@ namespace FluidProperties { this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } - if (LowErrorThisTime) { + if (error == GlycolError::DensityLow) { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] density **", routineName, this->Name), - glycolError.DensityLowErrIndex, + this->errors[(int)GlycolError::DensityLow].index, Temperature, Temperature, _, @@ -7477,11 +5229,9 @@ namespace FluidProperties { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetDensityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}: Temperature is out of range (too high) for fluid [{}] density **", - routineName, - this->Name)); + if ((error == GlycolError::DensityHigh) && + (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest)) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] density **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -7490,10 +5240,10 @@ namespace FluidProperties { this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } - if (HighErrorThisTime) { + if (error == GlycolError::DensityHigh) { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] density **", routineName, this->Name), - glycolError.DensityHighErrIndex, + this->errors[(int)GlycolError::DensityHigh].index, Temperature, Temperature, _, @@ -7506,7 +5256,7 @@ namespace FluidProperties { } Real64 GetDensityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name + std::string_view const glycolName, // carries in substance name Real64 const Temperature, // actual temperature given as input int &GlycolIndex, // Index to Glycol Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -7531,39 +5281,22 @@ namespace FluidProperties { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // Return value - Real64 ReturnValue; - - // FUNCTION PARAMETERS: - static constexpr std::string_view RoutineName = "GetConductivityGlycol"; - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - - // If no glycols, no fluid properties can be evaluated - int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) - ReportFatalGlycolErrors(state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); - - // If glycol index has not yet been found for this fluid, find its value now - if (GlycolIndex > 0) { - GlycolNum = GlycolIndex; - } else { // Find which refrigerant (index) is being requested - GlycolNum = GetGlycolNum(state, Glycol); - if (GlycolNum == 0) { - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetDensityGlycol", "density", CalledFrom); + auto &df = state.dataFluidProps; + + if (GlycolIndex == 0) { + if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { + ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - GlycolIndex = GlycolNum; } - return state.dataFluidProps->GlycolData(GlycolIndex).getDensity(state, Temperature, CalledFrom); + return df->GlycolData(GlycolIndex).getDensity(state, Temperature, CalledFrom); } //***************************************************************************** - Real64 GlycolData::getConductivity(EnergyPlusData &state, + Real64 GlycolProps::getConductivity(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) @@ -7591,30 +5324,26 @@ namespace FluidProperties { Real64 ReturnValue; // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "GlycolData::getConductivity"; + static constexpr std::string_view routineName = "GlycolProps::getConductivity"; // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; + GlycolError error = GlycolError::Invalid; + auto &df = state.dataFluidProps; + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!this->CondDataPresent) { - ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, - this->Num, - this->CondDataPresent, - this->Name, - "GetConductivityGlycol", - "conductivity", - CalledFrom); + ShowSevereError(state, format("{}: conductivity data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } // Now determine the value of specific heat using interpolation if (Temperature < this->CondLowTempValue) { // Temperature too low - LowErrorThisTime = true; + error = GlycolError::ConductivityLow; ReturnValue = this->CondValues(this->CondLowTempIndex); } else if (Temperature > this->CondHighTempValue) { // Temperature too high - HighErrorThisTime = true; + error = GlycolError::ConductivityHigh; ReturnValue = this->CondValues(this->CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPts); @@ -7623,34 +5352,24 @@ namespace FluidProperties { } // Error handling - if (!state.dataGlobal->WarmupFlag) { - auto &glycolError = state.dataFluidProps->GlycolErrorTracking(this->Num); - if (LowErrorThisTime) { - ++glycolError.ConductivityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetConductivityGlycol = glycolError.ConductivityLowErrCount; - } - if (HighErrorThisTime) { - ++glycolError.ConductivityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetConductivityGlycol = glycolError.ConductivityHighErrCount; - } + if (!state.dataGlobal->WarmupFlag && error != GlycolError::Invalid) { + df->glycolErrorLimits[(int)error] = this->errors[(int)error].count; + + if (error == GlycolError::ConductivityLow) { + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] conductivity **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->CondLowTempValue, + this->CondHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetConductivityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}: Temperature is out of range (too low) for fluid [{}] conductivity **", - routineName, - this->Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->CondLowTempValue, - this->CondHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } - if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), - glycolError.ConductivityLowErrIndex, + this->errors[(int)error].index, Temperature, Temperature, _, @@ -7658,23 +5377,21 @@ namespace FluidProperties { "{C}"); } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetConductivityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}: Temperature is out of range (too high) for fluid [{}] conductivity **", - routineName, - this->Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->CondLowTempValue, - this->CondHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } - if (HighErrorThisTime) { + else if (error == GlycolError::ConductivityHigh) { + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] conductivity **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->CondLowTempValue, + this->CondHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } + ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), - glycolError.ConductivityHighErrIndex, + this->errors[(int)error].index, Temperature, Temperature, _, @@ -7684,10 +5401,10 @@ namespace FluidProperties { } return ReturnValue; - } + } // GlycolProps::getConductivity() Real64 GetConductivityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name + std::string_view const glycolName, // carries in substance name Real64 const Temperature, // actual temperature given as input int &GlycolIndex, // Index to Glycol Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -7711,36 +5428,23 @@ namespace FluidProperties { // REFERENCES: // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - - // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; - - // If no glycols, no fluid properties can be evaluated - int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); - - // If glycol index has not yet been found for this fluid, find its value now - if (GlycolIndex > 0) { - GlycolNum = GlycolIndex; - } else { // Find which refrigerant (index) is being requested - GlycolNum = GetGlycolNum(state, Glycol); - if (GlycolNum == 0) { - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetConductivityGlycol", "conductivity", CalledFrom); + auto &df = state.dataFluidProps; + + if (GlycolIndex == 0) { + if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { + ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - GlycolIndex = GlycolNum; } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - return state.dataFluidProps->GlycolData(GlycolIndex).getConductivity(state, Temperature, CalledFrom); + return df->GlycolData(GlycolIndex).getConductivity(state, Temperature, CalledFrom); } //***************************************************************************** - Real64 GlycolData::getViscosity(EnergyPlusData &state, + Real64 GlycolProps::getViscosity(EnergyPlusData &state, Real64 const Temperature, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) @@ -7768,30 +5472,26 @@ namespace FluidProperties { Real64 ReturnValue; // Value for function // FUNCTION PARAMETERS: - static constexpr std::string_view routineName = "GlycolData::getViscosity"; + static constexpr std::string_view routineName = "GlycolProps::getViscosity"; // FUNCTION LOCAL VARIABLE DECLARATIONS: - bool LowErrorThisTime = false; - bool HighErrorThisTime = false; + GlycolError error = GlycolError::Invalid; + + auto &df = state.dataFluidProps; // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!this->ViscDataPresent) { - ReportFatalGlycolErrors(state, - state.dataFluidProps->NumOfGlycols, - this->Num, - this->ViscDataPresent, - this->Name, - "GetViscosityGlycol", - "viscosity", - CalledFrom); + ShowSevereError(state, format("{}: viscosity data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } // Now determine the value of specific heat using interpolation if (Temperature < this->ViscLowTempValue) { // Temperature too low - LowErrorThisTime = true; + error = GlycolError::ViscosityLow; ReturnValue = this->ViscValues(this->ViscLowTempIndex); } else if (Temperature > this->ViscHighTempValue) { // Temperature too high - HighErrorThisTime = true; + error = GlycolError::ViscosityHigh; ReturnValue = this->ViscValues(this->ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value int LoTempIndex = FindArrayIndex(Temperature, this->ViscTemps, 1, this->NumViscTempPts); @@ -7800,58 +5500,46 @@ namespace FluidProperties { } // Error handling - if (!state.dataGlobal->WarmupFlag) { - auto &glycolError = state.dataFluidProps->GlycolErrorTracking(this->Num); - if (LowErrorThisTime) { - ++glycolError.ViscosityLowErrCount; - state.dataFluidProps->LowTempLimitErrGetViscosityGlycol = glycolError.ViscosityLowErrCount; - } - if (HighErrorThisTime) { - ++glycolError.ViscosityHighErrCount; - state.dataFluidProps->HighTempLimitErrGetViscosityGlycol = glycolError.ViscosityHighErrCount; - } + if (!state.dataGlobal->WarmupFlag && error != GlycolError::Invalid) { + df->glycolErrorLimits[(int)error] = ++this->errors[(int)error].count; + + if (error == GlycolError::ViscosityHigh) { + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] viscosity **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->ViscLowTempValue, + this->ViscHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } - if ((LowErrorThisTime) && (state.dataFluidProps->LowTempLimitErrGetViscosityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}: Temperature is out of range (too low) for fluid [{}] viscosity **", - routineName, - glycolError.Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->ViscLowTempValue, - this->ViscHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } - if (LowErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too low) for fluid [{}] viscosity **", routineName, glycolError.Name), - glycolError.ViscosityLowErrIndex, + format("{}: Temperature out of range (too low) for fluid [{}] viscosity **", routineName, this->Name), + this->errors[(int)GlycolError::ViscosityLow].index, Temperature, Temperature, _, "{C}", "{C}"); } + + if (error == GlycolError::ViscosityHigh) { + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] viscosity **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->ViscLowTempValue, + this->ViscHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } - if ((HighErrorThisTime) && (state.dataFluidProps->HighTempLimitErrGetViscosityGlycol <= state.dataFluidProps->GlycolErrorLimitTest)) { - ShowWarningMessage(state, - format("{}Temperature is out of range (too high) for fluid [{}] viscosity **", - routineName, - glycolError.Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->ViscLowTempValue, - this->ViscHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } - if (HighErrorThisTime) { ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too high) for fluid [{}] viscosity **", routineName, glycolError.Name), - glycolError.ViscosityHighErrIndex, + format("{}: Temperature out of range (too high) for fluid [{}] viscosity **", routineName, this->Name), + this->errors[(int)GlycolError::ViscosityHigh].index, Temperature, Temperature, _, @@ -7861,10 +5549,10 @@ namespace FluidProperties { } return ReturnValue; - } + } // GlycolProps::getViscosity() Real64 GetViscosityGlycol(EnergyPlusData &state, - std::string_view const Glycol, // carries in substance name + std::string_view const glycolName, // carries in substance name Real64 const Temperature, // actual temperature given as input int &GlycolIndex, // Index to Glycol Properties std::string_view const CalledFrom // routine this function was called from (error messages) @@ -7889,26 +5577,18 @@ namespace FluidProperties { // GetFluidPropertiesData: subroutine enforces that temperatures in // all temperature lists are entered in ascending order. - // If no glycols, no fluid properties can be evaluated - int GlycolNum = 0; - if (state.dataFluidProps->NumOfGlycols == 0) - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); - - // If glycol index has not yet been found for this fluid, find its value now - if (GlycolIndex > 0) { - GlycolNum = GlycolIndex; - } else { // Find which refrigerant (index) is being requested - GlycolNum = GetGlycolNum(state, Glycol); - if (GlycolNum == 0) { - ReportFatalGlycolErrors( - state, state.dataFluidProps->NumOfGlycols, GlycolNum, true, Glycol, "GetViscosityGlycol", "viscosity", CalledFrom); + auto &df = state.dataFluidProps; + + if (GlycolIndex == 0) { + if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { + ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0.0; } - GlycolIndex = GlycolNum; } // Now determine the value of specific heat using interpolation - return state.dataFluidProps->GlycolData(GlycolIndex).getViscosity(state, Temperature, CalledFrom); + return df->GlycolData(GlycolIndex).getViscosity(state, Temperature, CalledFrom); } //***************************************************************************** @@ -7937,18 +5617,27 @@ namespace FluidProperties { // yet for some reason, that must be done. // Check to see if this glycol shows up in the glycol data - int refrigNum = Util::FindItemInList(Util::makeUPPER(name), state.dataFluidProps->RefrigData); + auto &df = state.dataFluidProps; + + if (df->NumOfRefrigerants == 0) { + ShowSevereError(state, "No refrigerants found."); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0; + } + + int refrigNum = Util::FindItemInList(Util::makeUPPER(name), df->RefrigData); if (refrigNum > 0) { - state.dataFluidProps->RefrigUsed(refrigNum) = true; + df->RefrigData(refrigNum).used = true; } return refrigNum; } - RefrigerantData *GetRefrig(EnergyPlusData &state, std::string_view const name) { + RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view const name) { + auto &df = state.dataFluidProps; int refrigNum = GetRefrigNum(state, name); - return (refrigNum > 0) ? &state.dataFluidProps->RefrigData(refrigNum) : nullptr; + return (refrigNum > 0) ? &df->RefrigData(refrigNum) : nullptr; } //***************************************************************************** @@ -7972,20 +5661,26 @@ namespace FluidProperties { // yet for some reason, that must be done. // Check to see if this glycol shows up in the glycol data - int glycolNum = Util::FindItemInList(Util::makeUPPER(name), - state.dataFluidProps->GlycolData, - state.dataFluidProps->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs + auto &df = state.dataFluidProps; + if (df->NumOfGlycols == 0) { + ShowSevereError(state, "No glycols found."); + ShowFatalError(state, "Program terminates due to preceding condition."); + return 0; + } + + int glycolNum = Util::FindItemInList(Util::makeUPPER(name), df->GlycolData, df->NumOfGlycols); if (glycolNum > 0) { - state.dataFluidProps->GlycolUsed(glycolNum) = true; + df->GlycolData(glycolNum).used = true; } return glycolNum; } - GlycolData *GetGlycol(EnergyPlusData &state, std::string_view const name) { - int glycolNum = GetGlycolNum(state, name); - return (glycolNum > 0) ? &state.dataFluidProps->GlycolData(glycolNum) : nullptr; + GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view const glycolName) { + auto &df = state.dataFluidProps; + int glycolNum = GetGlycolNum(state, glycolName); + return (glycolNum > 0) ? &df->GlycolData(glycolNum) : nullptr; } //***************************************************************************** @@ -8011,8 +5706,9 @@ namespace FluidProperties { // Check to see if this glycol shows up in the glycol data // ArrayLength = SIZE(GlycolData) - if (Idx > 0 && Idx <= state.dataFluidProps->NumOfGlycols) { - return state.dataFluidProps->GlycolData(Idx).Name; + auto &df = state.dataFluidProps; + if (Idx > 0 && Idx <= df->NumOfGlycols) { + return df->GlycolData(Idx).Name; } else { // return blank - error checking in calling proceedure return ""; } @@ -8154,6 +5850,8 @@ namespace FluidProperties { // Return value Real64 ReturnValue; + auto &df = state.dataFluidProps; + // error counters and dummy string bool ErrorFlag(false); // error flag for current call @@ -8184,9 +5882,9 @@ namespace FluidProperties { } if (ErrorFlag && (CalledFrom != "ReportAndTestRefrigerants")) { - ++state.dataFluidProps->TempRangeErrCountGetInterpolatedSatProp; + ++df->TempRangeErrCountGetInterpolatedSatProp; // send warning - if (state.dataFluidProps->TempRangeErrCountGetInterpolatedSatProp <= state.dataFluidProps->RefrigerantErrorLimitTest) { + if (df->TempRangeErrCountGetInterpolatedSatProp <= df->RefrigErrorLimitTest) { ShowWarningError(state, "GetInterpolatedSatProp: Saturation temperature for interpolation is out of range of data supplied: **"); ShowContinueErrorTimeStamp(state, fmt::format(" Called from:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); @@ -8194,7 +5892,7 @@ namespace FluidProperties { } else { ShowRecurringWarningErrorAtEnd(state, "GetInterpolatedSatProp: Refrigerant temperature for interpolation out of range error", - state.dataFluidProps->TempRangeErrIndexGetInterpolatedSatProp, + df->TempRangeErrIndexGetInterpolatedSatProp, Temperature, Temperature, _, @@ -8218,25 +5916,18 @@ namespace FluidProperties { // PURPOSE OF THIS FUNCTION: // This function checks on an input fluid property to make sure it is valid. - - // Return value - int CheckFluidPropertyName; - + auto &df = state.dataFluidProps; + // Item must be either in Refrigerant or Glycol list int Found = 0; - if (state.dataFluidProps->NumOfRefrigerants > 0) { - Found = Util::FindItemInList(NameToCheck, state.dataFluidProps->RefrigData); + if (df->NumOfRefrigerants > 0) { + Found = Util::FindItemInList(NameToCheck, df->RefrigData); } - if (Found == 0) { - if (state.dataFluidProps->NumOfGlycols > 0) { - Found = Util::FindItemInList( - NameToCheck, state.dataFluidProps->GlycolData, state.dataFluidProps->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs - } + if (Found == 0 && df->NumOfGlycols > 0) { + Found = Util::FindItemInList(NameToCheck, df->GlycolData, df->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs } - CheckFluidPropertyName = Found; - - return CheckFluidPropertyName; + return Found; } void ReportOrphanFluids(EnergyPlusData &state) @@ -8253,16 +5944,18 @@ namespace FluidProperties { bool NeedOrphanMessage = true; int NumUnusedRefrig = 0; - for (int Item = 1; Item <= state.dataFluidProps->NumOfRefrigerants; ++Item) { - if (state.dataFluidProps->RefrigUsed(Item)) continue; - if (Util::SameString(state.dataFluidProps->RefrigData(Item).Name, Steam)) continue; + auto &df = state.dataFluidProps; + + for (int Item = 1; Item <= df->NumOfRefrigerants; ++Item) { + if (df->RefrigData(Item).used) continue; + if (Util::SameString(df->RefrigData(Item).Name, Steam)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Refrigerant={}", state.dataFluidProps->RefrigData(Item).Name)); + ShowMessage(state, format("Refrigerant={}", df->RefrigData(Item).Name)); } else { ++NumUnusedRefrig; } @@ -8270,18 +5963,18 @@ namespace FluidProperties { int NumUnusedGlycol = 0; - for (int Item = 1; Item <= state.dataFluidProps->NumOfGlycols; ++Item) { - if (state.dataFluidProps->GlycolUsed(Item)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, Water)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, EthyleneGlycol)) continue; - if (Util::SameString(state.dataFluidProps->GlycolData(Item).Name, PropyleneGlycol)) continue; + for (int Item = 1; Item <= df->NumOfGlycols; ++Item) { + if (df->GlycolData(Item).used) continue; + if (Util::SameString(df->GlycolData(Item).Name, Water)) continue; + if (Util::SameString(df->GlycolData(Item).Name, EthyleneGlycol)) continue; + if (Util::SameString(df->GlycolData(Item).Name, PropyleneGlycol)) continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Glycol={}", state.dataFluidProps->GlycolData(Item).Name)); + ShowMessage(state, format("Glycol={}", df->GlycolData(Item).Name)); } else { ++NumUnusedGlycol; } @@ -8294,108 +5987,22 @@ namespace FluidProperties { } } - void ReportFatalGlycolErrors(EnergyPlusData &state, - int const NumGlycols, // Number of Glycols in input/data - int const GlycolNum, // Glycol Index - bool const DataPresent, // data is present for this fluid. - std::string_view const GlycolName, // Name being reported - std::string_view const RoutineName, // Routine name to show - std::string_view const Property, // Property being requested - std::string_view const CalledFrom // original called from (external to fluid properties) - ) - { - - // SUBROUTINE INFORMATION: - // AUTHOR Linda Lawrie - // DATE WRITTEN July 2011 - - // PURPOSE OF THIS SUBROUTINE: - // Consolidate fatal error reporting for glycols. - - // check and see if it might be a refrigerant - int RefrigNo = GetRefrigNum(state, GlycolName); - - if (NumGlycols == 0) { - ShowSevereError( - state, - fmt::format( - "{}: no glycols found -- cannot evaluate fluid {} for \"{}\", called from: {}", RoutineName, Property, GlycolName, CalledFrom)); - } else if (GlycolNum == 0) { - ShowSevereError( - state, fmt::format("{}: data not found in input for requested glycol \"{}\", called from: {}", RoutineName, GlycolName, CalledFrom)); - } else if (!DataPresent) { - ShowSevereError(state, - format("{}: {} data not found in input for requested glycol \"{}{}", - RoutineName, - Property, - GlycolName, - fmt::format("\", called from: {}", CalledFrom))); - } - if (RefrigNo > 0) ShowContinueError(state, "Note: that fluid is listed as a Refrigerant from input."); - - ShowFatalError(state, "Program terminates due to preceding condition."); - } - - void ReportFatalRefrigerantErrors(EnergyPlusData &state, - int const NumRefrigerants, // Number of Refrigerants in input/data - int const RefrigerantNum, // Refrigerant Index - bool const DataPresent, // data is present for this fluid. - std::string_view const RefrigerantName, // Name being reported - std::string_view const RoutineName, // Routine name to show - std::string_view const Property, // Property being requested - std::string_view const CalledFrom // original called from (external to fluid properties) - ) - { - - // SUBROUTINE INFORMATION: - // AUTHOR Linda Lawrie - // DATE WRITTEN July 2011 - - // PURPOSE OF THIS SUBROUTINE: - // Consolidate fatal error reporting for refrigerants. - - // check and see if it might be a refrigerant - int GlycolNo = GetGlycolNum(state, RefrigerantName); - - if (NumRefrigerants == 0) { - ShowSevereError(state, - fmt::format("{}: no refrigerants found -- cannot evaluate fluid {} for \"{}\", called from: {}", - RoutineName, - Property, - RefrigerantName, - CalledFrom)); - } else if (RefrigerantNum == 0) { - ShowSevereError( - state, - fmt::format( - "{}: data not found in input for requested refrigerant \"{}\", called from: {}", RoutineName, RefrigerantName, CalledFrom)); - } else if (!DataPresent) { - ShowSevereError(state, - fmt::format("{}: {} data not found in input for requested refrigerant \"{}\", called from: {}", - RoutineName, - Property, - RefrigerantName, - CalledFrom)); - } - if (GlycolNo > 0) ShowContinueError(state, "Note: that fluid is listed as a Glycol from input."); - - ShowFatalError(state, "Program terminates due to preceding condition."); - } void GetFluidDensityTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { - if (FluidIndex > 0) { - MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoLowTempValue; - MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).RhoHighTempValue; + auto &df = state.dataFluidProps; + MinTempLimit = df->GlycolData(FluidIndex).RhoLowTempValue; + MaxTempLimit = df->GlycolData(FluidIndex).RhoHighTempValue; } } void GetFluidSpecificHeatTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { if (FluidIndex > 0) { - MinTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpLowTempValue; - MaxTempLimit = state.dataFluidProps->GlycolData(FluidIndex).CpHighTempValue; + auto &df = state.dataFluidProps; + MinTempLimit = df->GlycolData(FluidIndex).CpLowTempValue; + MaxTempLimit = df->GlycolData(FluidIndex).CpHighTempValue; } } @@ -8467,6 +6074,1946 @@ namespace FluidProperties { return FluidProperties::GetSupHeatDensityRefrig(state, this->rName, temperature, pressure, this->rIndex, this->cf); } +#ifdef UNUSED_FLUID_PROPS + static constexpr std::array, DefaultNumSteamSuperheatedPressure> + DefaultSteamSuperheatedEnthalpyDataTable = { + {{2501000.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 2510000.0, 2519000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 2519000.0, 2529000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 2528000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2622000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 2537000.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, + 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2584000.0, 2594000.0, + 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2556000.0, 2565000.0, 2575000.0, 2584000.0, 2594000.0, + 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, + 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2565000.0, 2574000.0, 2584000.0, 2593000.0, + 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2661000.0, + 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2574000.0, 2583000.0, 2593000.0, + 2602000.0, 2612000.0, 2621000.0, 2631000.0, 2635000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2657000.0, 2661000.0, + 2665000.0, 2669000.0, 2673000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2582000.0, 2592000.0, + 2602000.0, 2611000.0, 2621000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2649000.0, 2653000.0, 2657000.0, 2661000.0, + 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2775000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2591000.0, + 2601000.0, 2611000.0, 2620000.0, 2630000.0, 2634000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, 2660000.0, + 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2600000.0, 2610000.0, 2620000.0, 2629000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2648000.0, 2652000.0, 2656000.0, 2660000.0, + 2664000.0, 2668000.0, 2671000.0, 2675000.0, 2679000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2692000.0, 2694000.0, + 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2715000.0, 2717000.0, + 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, 2740000.0, + 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, + 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2609000.0, 2619000.0, 2628000.0, 2632000.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2655000.0, 2659000.0, + 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, + 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, + 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, + 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2778000.0, 2782000.0, + 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2836000.0, 2840000.0, 2850000.0, 2860000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2908000.0, 2918000.0, 2928000.0, + 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3076000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2618000.0, 2627000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2659000.0, + 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, + 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2716000.0, + 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, + 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, + 2786000.0, 2790000.0, 2794000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2850000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, + 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2626000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, + 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, + 2695000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, + 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, + 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, + 2937000.0, 2957000.0, 2977000.0, 2997000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2630000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, + 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, + 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, + 2741000.0, 2743000.0, 2747000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, + 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, + 2661000.0, 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, + 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, + 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, + 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2917000.0, 2927000.0, + 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, + 2660000.0, 2664000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, + 2659000.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2646000.0, 2650000.0, 2654000.0, + 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, + 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, + 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2650000.0, 2654000.0, + 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, + 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, + 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, + 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2653000.0, + 2657000.0, 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, + 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, + 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2732000.0, 2734000.0, 2736000.0, + 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2926000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3035000.0, 3055000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2656000.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, + 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, + 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, + 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2916000.0, 2926000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, + 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, + 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2735000.0, + 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2936000.0, 2956000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, + 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, + 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, + 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2774000.0, 2778000.0, + 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2936000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2666000.0, 2670000.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, + 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, + 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, + 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, + 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, + 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2669000.0, 2673000.0, 2675000.0, 2677000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, + 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, + 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, + 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, + 2829000.0, 2833000.0, 2837000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2672000.0, 2674000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, + 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, + 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, + 2686000.0, 2688000.0, 2690000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, + 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, + 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, + 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2679000.0, 2681000.0, 2683000.0, + 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2680000.0, 2682000.0, + 2684000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, + 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2682000.0, + 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, + 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, + 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2683000.0, 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, + 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, + 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, + 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2686000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, + 2707000.0, 2709000.0, 2711000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, + 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, + 2706000.0, 2708000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, + 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, + 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2727000.0, 2729000.0, + 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, + 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, + 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2703000.0, + 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2724000.0, 2726000.0, 2728000.0, + 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, + 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, + 2729000.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2697000.0, 2699000.0, 2701000.0, + 2703000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2725000.0, 2727000.0, + 2729000.0, 2731000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2699000.0, 2701000.0, + 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, + 2728000.0, 2730000.0, 2734000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3174000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2700000.0, + 2702000.0, 2704000.0, 2706000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2726000.0, + 2728000.0, 2730000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, + 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, + 2727000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2771000.0, + 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, + 2726000.0, 2729000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, + 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2704000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, 2722000.0, 2724000.0, + 2726000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2766000.0, 2770000.0, + 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, + 2725000.0, 2727000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, + 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2707000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, + 2725000.0, 2727000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, + 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2718000.0, 2720000.0, 2722000.0, + 2724000.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, + 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, + 2723000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, 2768000.0, + 2772000.0, 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, + 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, + 2723000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, + 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2813000.0, 2817000.0, + 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2970000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, + 2722000.0, 2724000.0, 2728000.0, 2733000.0, 2737000.0, 2741000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2767000.0, + 2771000.0, 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, + 2820000.0, 2824000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2758000.0, 2762000.0, 2766000.0, + 2770000.0, 2774000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, 2816000.0, + 2820000.0, 2824000.0, 2828000.0, 2838000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, + 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3010000.0, 3031000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2716000.0, 2718000.0, + 2720000.0, 2723000.0, 2727000.0, 2731000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, + 2770000.0, 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, + 2819000.0, 2824000.0, 2828000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, + 2929000.0, 2949000.0, 2970000.0, 2990000.0, 3010000.0, 3030000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3152000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2717000.0, + 2720000.0, 2722000.0, 2726000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2761000.0, 2765000.0, + 2769000.0, 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2807000.0, 2811000.0, 2815000.0, + 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2899000.0, 2909000.0, 2919000.0, + 2929000.0, 2949000.0, 2969000.0, 2990000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2719000.0, 2721000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, + 2768000.0, 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, + 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2847000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2919000.0, + 2929000.0, 2949000.0, 2969000.0, 2989000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2720000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, + 2768000.0, 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2806000.0, 2810000.0, 2814000.0, + 2818000.0, 2822000.0, 2826000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, + 2928000.0, 2949000.0, 2969000.0, 2989000.0, 3009000.0, 3030000.0, 3050000.0, 3070000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2723000.0, 2727000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, + 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2805000.0, 2809000.0, 2813000.0, + 2817000.0, 2821000.0, 2825000.0, 2836000.0, 2846000.0, 2856000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2918000.0, + 2928000.0, 2948000.0, 2968000.0, 2989000.0, 3009000.0, 3029000.0, 3050000.0, 3070000.0, 3090000.0, 3111000.0, 3131000.0, 3152000.0, + 3172000.0, 3193000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, 2757000.0, 2761000.0, + 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, + 2816000.0, 2820000.0, 2824000.0, 2835000.0, 2845000.0, 2855000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2907000.0, 2917000.0, + 2927000.0, 2947000.0, 2968000.0, 2988000.0, 3008000.0, 3029000.0, 3049000.0, 3069000.0, 3090000.0, 3110000.0, 3131000.0, 3151000.0, + 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2728000.0, 2733000.0, 2737000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, + 2764000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, + 2815000.0, 2819000.0, 2823000.0, 2834000.0, 2844000.0, 2854000.0, 2865000.0, 2875000.0, 2885000.0, 2896000.0, 2906000.0, 2916000.0, + 2926000.0, 2947000.0, 2967000.0, 2987000.0, 3008000.0, 3028000.0, 3049000.0, 3069000.0, 3089000.0, 3110000.0, 3130000.0, 3151000.0, + 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2749000.0, 2753000.0, 2758000.0, + 2762000.0, 2767000.0, 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, + 2814000.0, 2818000.0, 2822000.0, 2833000.0, 2843000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, + 2926000.0, 2946000.0, 2966000.0, 2987000.0, 3007000.0, 3028000.0, 3048000.0, 3069000.0, 3089000.0, 3109000.0, 3130000.0, 3151000.0, + 3171000.0, 3192000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2733000.0, 2738000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, + 2761000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, + 2812000.0, 2817000.0, 2821000.0, 2831000.0, 2842000.0, 2852000.0, 2863000.0, 2873000.0, 2884000.0, 2894000.0, 2904000.0, 2915000.0, + 2925000.0, 2945000.0, 2966000.0, 2986000.0, 3007000.0, 3027000.0, 3048000.0, 3068000.0, 3089000.0, 3109000.0, 3130000.0, 3150000.0, + 3171000.0, 3191000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2736000.0, 2741000.0, 2745000.0, 2750000.0, 2754000.0, + 2759000.0, 2763000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2803000.0, 2807000.0, + 2811000.0, 2815000.0, 2820000.0, 2830000.0, 2841000.0, 2851000.0, 2862000.0, 2872000.0, 2883000.0, 2893000.0, 2903000.0, 2914000.0, + 2924000.0, 2945000.0, 2965000.0, 2986000.0, 3006000.0, 3027000.0, 3047000.0, 3068000.0, 3088000.0, 3109000.0, 3129000.0, 3150000.0, + 3170000.0, 3191000.0, 3212000.0, 3280000.0, 3379000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, + 2757000.0, 2761000.0, 2766000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, + 2810000.0, 2814000.0, 2818000.0, 2829000.0, 2840000.0, 2850000.0, 2861000.0, 2871000.0, 2882000.0, 2892000.0, 2902000.0, 2913000.0, + 2923000.0, 2944000.0, 2964000.0, 2985000.0, 3005000.0, 3026000.0, 3046000.0, 3067000.0, 3088000.0, 3108000.0, 3129000.0, 3149000.0, + 3170000.0, 3191000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2741000.0, 2746000.0, 2750000.0, + 2755000.0, 2760000.0, 2764000.0, 2769000.0, 2773000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, + 2808000.0, 2813000.0, 2817000.0, 2828000.0, 2838000.0, 2849000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2912000.0, + 2922000.0, 2943000.0, 2964000.0, 2984000.0, 3005000.0, 3025000.0, 3046000.0, 3066000.0, 3087000.0, 3108000.0, 3128000.0, 3149000.0, + 3170000.0, 3190000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2744000.0, 2748000.0, + 2753000.0, 2758000.0, 2762000.0, 2767000.0, 2771000.0, 2776000.0, 2780000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, + 2807000.0, 2811000.0, 2815000.0, 2826000.0, 2837000.0, 2848000.0, 2858000.0, 2869000.0, 2879000.0, 2890000.0, 2900000.0, 2911000.0, + 2921000.0, 2942000.0, 2963000.0, 2983000.0, 3004000.0, 3025000.0, 3045000.0, 3066000.0, 3086000.0, 3107000.0, 3128000.0, 3148000.0, + 3169000.0, 3190000.0, 3211000.0, 3280000.0, 3378000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2746000.0, + 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2801000.0, + 2805000.0, 2810000.0, 2814000.0, 2825000.0, 2836000.0, 2846000.0, 2857000.0, 2868000.0, 2878000.0, 2889000.0, 2899000.0, 2910000.0, + 2920000.0, 2941000.0, 2962000.0, 2983000.0, 3003000.0, 3024000.0, 3045000.0, 3065000.0, 3086000.0, 3106000.0, 3127000.0, 3148000.0, + 3169000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2748000.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2776000.0, 2781000.0, 2786000.0, 2790000.0, 2795000.0, 2799000.0, + 2803000.0, 2808000.0, 2812000.0, 2823000.0, 2834000.0, 2845000.0, 2856000.0, 2866000.0, 2877000.0, 2888000.0, 2898000.0, 2909000.0, + 2919000.0, 2940000.0, 2961000.0, 2982000.0, 3002000.0, 3023000.0, 3044000.0, 3064000.0, 3085000.0, 3106000.0, 3127000.0, 3147000.0, + 3168000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, + 2802000.0, 2806000.0, 2811000.0, 2822000.0, 2833000.0, 2843000.0, 2854000.0, 2865000.0, 2876000.0, 2886000.0, 2897000.0, 2908000.0, + 2918000.0, 2939000.0, 2960000.0, 2981000.0, 3002000.0, 3022000.0, 3043000.0, 3064000.0, 3085000.0, 3105000.0, 3126000.0, 3147000.0, + 3168000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, 2791000.0, 2795000.0, + 2800000.0, 2804000.0, 2809000.0, 2820000.0, 2831000.0, 2842000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2896000.0, 2906000.0, + 2917000.0, 2938000.0, 2959000.0, 2980000.0, 3001000.0, 3022000.0, 3042000.0, 3063000.0, 3084000.0, 3105000.0, 3125000.0, 3146000.0, + 3167000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2789000.0, 2793000.0, + 2798000.0, 2802000.0, 2807000.0, 2818000.0, 2829000.0, 2840000.0, 2851000.0, 2862000.0, 2873000.0, 2884000.0, 2894000.0, 2905000.0, + 2916000.0, 2937000.0, 2958000.0, 2979000.0, 3000000.0, 3021000.0, 3042000.0, 3062000.0, 3083000.0, 3104000.0, 3125000.0, 3146000.0, + 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2757000.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2782000.0, 2786000.0, 2791000.0, + 2796000.0, 2800000.0, 2805000.0, 2816000.0, 2827000.0, 2839000.0, 2850000.0, 2861000.0, 2872000.0, 2882000.0, 2893000.0, 2904000.0, + 2915000.0, 2936000.0, 2957000.0, 2978000.0, 2999000.0, 3020000.0, 3041000.0, 3062000.0, 3082000.0, 3103000.0, 3124000.0, 3145000.0, + 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3376000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2789000.0, + 2793000.0, 2798000.0, 2803000.0, 2814000.0, 2826000.0, 2837000.0, 2848000.0, 2859000.0, 2870000.0, 2881000.0, 2892000.0, 2902000.0, + 2913000.0, 2935000.0, 2956000.0, 2977000.0, 2998000.0, 3019000.0, 3040000.0, 3061000.0, 3082000.0, 3102000.0, 3123000.0, 3144000.0, + 3165000.0, 3186000.0, 3207000.0, 3280000.0, 3376000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, + 2791000.0, 2796000.0, 2800000.0, 2812000.0, 2824000.0, 2835000.0, 2846000.0, 2857000.0, 2868000.0, 2879000.0, 2890000.0, 2901000.0, + 2912000.0, 2933000.0, 2955000.0, 2976000.0, 2997000.0, 3018000.0, 3039000.0, 3060000.0, 3081000.0, 3102000.0, 3123000.0, 3144000.0, + 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2764000.0, 2769000.0, 2774000.0, 2779000.0, 2784000.0, + 2789000.0, 2793000.0, 2798000.0, 2810000.0, 2821000.0, 2833000.0, 2844000.0, 2855000.0, 2867000.0, 2878000.0, 2889000.0, 2900000.0, + 2910000.0, 2932000.0, 2953000.0, 2975000.0, 2996000.0, 3017000.0, 3038000.0, 3059000.0, 3080000.0, 3101000.0, 3122000.0, 3143000.0, + 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3482000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2766000.0, 2771000.0, 2776000.0, 2781000.0, + 2786000.0, 2791000.0, 2796000.0, 2808000.0, 2819000.0, 2831000.0, 2842000.0, 2854000.0, 2865000.0, 2876000.0, 2887000.0, 2898000.0, + 2909000.0, 2931000.0, 2952000.0, 2973000.0, 2995000.0, 3016000.0, 3037000.0, 3058000.0, 3079000.0, 3100000.0, 3121000.0, 3142000.0, + 3163000.0, 3184000.0, 3205000.0, 3280000.0, 3374000.0, 3482000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2768000.0, 2773000.0, 2778000.0, + 2783000.0, 2788000.0, 2793000.0, 2805000.0, 2817000.0, 2829000.0, 2840000.0, 2852000.0, 2863000.0, 2874000.0, 2885000.0, 2896000.0, + 2907000.0, 2929000.0, 2951000.0, 2972000.0, 2994000.0, 3015000.0, 3036000.0, 3057000.0, 3078000.0, 3099000.0, 3120000.0, 3141000.0, + 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3374000.0, 3481000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2770000.0, 2775000.0, + 2780000.0, 2785000.0, 2790000.0, 2802000.0, 2814000.0, 2826000.0, 2838000.0, 2850000.0, 2861000.0, 2872000.0, 2883000.0, 2895000.0, + 2906000.0, 2928000.0, 2949000.0, 2971000.0, 2992000.0, 3014000.0, 3035000.0, 3056000.0, 3077000.0, 3098000.0, 3119000.0, 3140000.0, + 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3373000.0, 3481000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2772000.0, + 2777000.0, 2782000.0, 2787000.0, 2800000.0, 2812000.0, 2824000.0, 2836000.0, 2847000.0, 2859000.0, 2870000.0, 2882000.0, 2893000.0, + 2904000.0, 2926000.0, 2948000.0, 2969000.0, 2991000.0, 3012000.0, 3034000.0, 3055000.0, 3076000.0, 3097000.0, 3118000.0, 3140000.0, + 3161000.0, 3182000.0, 3203000.0, 3280000.0, 3373000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2774000.0, 2779000.0, 2784000.0, 2797000.0, 2809000.0, 2821000.0, 2833000.0, 2845000.0, 2857000.0, 2868000.0, 2880000.0, 2891000.0, + 2902000.0, 2924000.0, 2946000.0, 2968000.0, 2990000.0, 3011000.0, 3033000.0, 3054000.0, 3075000.0, 3096000.0, 3118000.0, 3139000.0, + 3160000.0, 3181000.0, 3202000.0, 3280000.0, 3372000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2775000.0, 2781000.0, 2794000.0, 2806000.0, 2819000.0, 2831000.0, 2843000.0, 2854000.0, 2866000.0, 2878000.0, 2889000.0, + 2900000.0, 2923000.0, 2945000.0, 2967000.0, 2988000.0, 3010000.0, 3031000.0, 3053000.0, 3074000.0, 3095000.0, 3117000.0, 3138000.0, + 3159000.0, 3180000.0, 3201000.0, 3280000.0, 3372000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2777000.0, 2790000.0, 2803000.0, 2816000.0, 2828000.0, 2840000.0, 2852000.0, 2864000.0, 2875000.0, 2887000.0, + 2898000.0, 2921000.0, 2943000.0, 2965000.0, 2987000.0, 3009000.0, 3030000.0, 3052000.0, 3073000.0, 3094000.0, 3116000.0, 3137000.0, + 3158000.0, 3179000.0, 3201000.0, 3280000.0, 3371000.0, 3479000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2781000.0, 2795000.0, 2808000.0, 2821000.0, 2833000.0, 2846000.0, 2858000.0, 2870000.0, 2881000.0, + 2893000.0, 2916000.0, 2939000.0, 2961000.0, 2983000.0, 3005000.0, 3027000.0, 3048000.0, 3070000.0, 3091000.0, 3113000.0, 3134000.0, + 3156000.0, 3177000.0, 3198000.0, 3280000.0, 3370000.0, 3478000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2785000.0, 2799000.0, 2813000.0, 2826000.0, 2838000.0, 2851000.0, 2863000.0, 2875000.0, + 2887000.0, 2910000.0, 2933000.0, 2956000.0, 2979000.0, 3001000.0, 3023000.0, 3045000.0, 3067000.0, 3088000.0, 3110000.0, 3132000.0, + 3153000.0, 3175000.0, 3196000.0, 3280000.0, 3368000.0, 3476000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2789000.0, 2803000.0, 2817000.0, 2830000.0, 2843000.0, 2856000.0, 2868000.0, + 2880000.0, 2904000.0, 2928000.0, 2951000.0, 2974000.0, 2996000.0, 3019000.0, 3041000.0, 3063000.0, 3085000.0, 3107000.0, 3128000.0, + 3150000.0, 3172000.0, 3193000.0, 3280000.0, 3366000.0, 3475000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2792000.0, 2807000.0, 2821000.0, 2834000.0, 2847000.0, 2860000.0, + 2873000.0, 2898000.0, 2922000.0, 2945000.0, 2969000.0, 2992000.0, 3014000.0, 3037000.0, 3059000.0, 3081000.0, 3103000.0, 3125000.0, + 3147000.0, 3169000.0, 3190000.0, 3280000.0, 3364000.0, 3473000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2795000.0, 2810000.0, 2824000.0, 2838000.0, 2851000.0, + 2864000.0, 2890000.0, 2915000.0, 2939000.0, 2963000.0, 2986000.0, 3009000.0, 3032000.0, 3055000.0, 3077000.0, 3099000.0, 3121000.0, + 3143000.0, 3165000.0, 3187000.0, 3280000.0, 3362000.0, 3471000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2797000.0, 2813000.0, 2827000.0, 2841000.0, + 2855000.0, 2882000.0, 2907000.0, 2932000.0, 2956000.0, 2980000.0, 3004000.0, 3027000.0, 3050000.0, 3072000.0, 3095000.0, 3117000.0, + 3140000.0, 3162000.0, 3184000.0, 3280000.0, 3359000.0, 3469000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2799000.0, 2815000.0, 2830000.0, + 2844000.0, 2872000.0, 2899000.0, 2924000.0, 2949000.0, 2974000.0, 2998000.0, 3021000.0, 3044000.0, 3067000.0, 3090000.0, 3113000.0, + 3135000.0, 3158000.0, 3180000.0, 3280000.0, 3357000.0, 3467000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2801000.0, 2817000.0, + 2832000.0, 2862000.0, 2889000.0, 2916000.0, 2941000.0, 2966000.0, 2991000.0, 3015000.0, 3039000.0, 3062000.0, 3085000.0, 3108000.0, + 3131000.0, 3154000.0, 3176000.0, 3280000.0, 3354000.0, 3465000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2802000.0, + 2819000.0, 2850000.0, 2879000.0, 2906000.0, 2933000.0, 2958000.0, 2984000.0, 3008000.0, 3032000.0, 3056000.0, 3080000.0, 3103000.0, + 3126000.0, 3149000.0, 3172000.0, 3280000.0, 3351000.0, 3462000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2803000.0, 2836000.0, 2867000.0, 2895000.0, 2923000.0, 2950000.0, 2975000.0, 3001000.0, 3025000.0, 3050000.0, 3073000.0, 3097000.0, + 3121000.0, 3144000.0, 3167000.0, 3280000.0, 3348000.0, 3459000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2803000.0, 2838000.0, 2870000.0, 2900000.0, 2929000.0, 2957000.0, 2983000.0, 3009000.0, 3035000.0, 3060000.0, 3084000.0, + 3108000.0, 3132000.0, 3156000.0, 3280000.0, 3340000.0, 3453000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2801000.0, 2838000.0, 2872000.0, 2904000.0, 2934000.0, 2963000.0, 2990000.0, 3017000.0, 3043000.0, 3069000.0, + 3094000.0, 3119000.0, 3143000.0, 3280000.0, 3332000.0, 3446000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2797000.0, 2837000.0, 2873000.0, 2906000.0, 2937000.0, 2967000.0, 2996000.0, 3023000.0, 3050000.0, + 3077000.0, 3103000.0, 3128000.0, 3280000.0, 3322000.0, 3438000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2790000.0, 2833000.0, 2871000.0, 2906000.0, 2939000.0, 2970000.0, 3000000.0, 3029000.0, + 3057000.0, 3084000.0, 3110000.0, 3280000.0, 3310000.0, 3429000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2780000.0, 2826000.0, 2867000.0, 2905000.0, 2939000.0, 2972000.0, 3003000.0, + 3033000.0, 3062000.0, 3090000.0, 3280000.0, 3297000.0, 3418000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2767000.0, 2817000.0, + 2861000.0, 2901000.0, 2938000.0, 2972000.0, 3004000.0, 3036000.0, 3066000.0, 3280000.0, 3282000.0, 3406000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2750000.0, + 2806000.0, 2853000.0, 2895000.0, 2934000.0, 2970000.0, 3004000.0, 3037000.0, 3280000.0, 3264000.0, 3392000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2728000.0, + 2790000.0, 2842000.0, 2887000.0, 2929000.0, 2967000.0, 3003000.0, 3280000.0, 3244000.0, 3377000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2701000.0, 2771000.0, 2828000.0, 2877000.0, 2921000.0, 2961000.0, 3280000.0, 3222000.0, 3359000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2666000.0, 2747000.0, 2810000.0, 2864000.0, 2911000.0, 3280000.0, 3195000.0, 3339000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2622000.0, 2718000.0, 2789000.0, 2847000.0, 3280000.0, 3165000.0, 3316000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2564000.0, 2683000.0, 2763000.0, 3280000.0, 3130000.0, 3290000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2481000.0, 2641000.0, 3280000.0, 3089000.0, 3260000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2335000.0, 3280000.0, 3040000.0, 3226000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2821000.0, 3085000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2671000.0, 2998000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2512000.0, 2906000.0}} + }; + + static constexpr std::array, DefaultNumSteamSuperheatedPressure> + DefaultSteamSuperheatedDensityDataTable = { + {{4.855e-03, 4.837e-03, 4.767e-03, 4.683e-03, 4.601e-03, 4.522e-03, 4.446e-03, 4.373e-03, 4.302e-03, 4.233e-03, 4.167e-03, 4.102e-03, + 4.039e-03, 3.979e-03, 3.920e-03, 3.863e-03, 3.840e-03, 3.818e-03, 3.796e-03, 3.775e-03, 3.753e-03, 3.732e-03, 3.711e-03, 3.691e-03, + 3.670e-03, 3.650e-03, 3.630e-03, 3.610e-03, 3.591e-03, 3.571e-03, 3.562e-03, 3.552e-03, 3.543e-03, 3.533e-03, 3.524e-03, 3.514e-03, + 3.505e-03, 3.496e-03, 3.487e-03, 3.477e-03, 3.468e-03, 3.459e-03, 3.450e-03, 3.441e-03, 3.432e-03, 3.424e-03, 3.415e-03, 3.406e-03, + 3.397e-03, 3.388e-03, 3.380e-03, 3.371e-03, 3.363e-03, 3.354e-03, 3.346e-03, 3.337e-03, 3.329e-03, 3.321e-03, 3.312e-03, 3.304e-03, + 3.296e-03, 3.288e-03, 3.271e-03, 3.255e-03, 3.239e-03, 3.224e-03, 3.208e-03, 3.193e-03, 3.177e-03, 3.162e-03, 3.147e-03, 3.132e-03, + 3.117e-03, 3.103e-03, 3.088e-03, 3.074e-03, 3.060e-03, 3.046e-03, 3.032e-03, 3.018e-03, 3.004e-03, 2.991e-03, 2.977e-03, 2.964e-03, + 2.951e-03, 2.938e-03, 2.925e-03, 2.893e-03, 2.862e-03, 2.831e-03, 2.801e-03, 2.772e-03, 2.743e-03, 2.715e-03, 2.688e-03, 2.661e-03, + 2.634e-03, 2.583e-03, 2.533e-03, 2.486e-03, 2.440e-03, 2.396e-03, 2.353e-03, 2.312e-03, 2.273e-03, 2.234e-03, 2.197e-03, 2.162e-03, + 2.127e-03, 2.093e-03, 2.061e-03, 3.542e-05, 1.833e-03, 1.714e-03}, + {0.0, 5.196e-03, 5.121e-03, 5.031e-03, 4.943e-03, 4.859e-03, 4.777e-03, 4.698e-03, 4.622e-03, 4.548e-03, 4.476e-03, 4.407e-03, + 4.340e-03, 4.274e-03, 4.211e-03, 4.150e-03, 4.126e-03, 4.102e-03, 4.078e-03, 4.055e-03, 4.032e-03, 4.009e-03, 3.987e-03, 3.965e-03, + 3.943e-03, 3.921e-03, 3.899e-03, 3.878e-03, 3.857e-03, 3.836e-03, 3.826e-03, 3.816e-03, 3.806e-03, 3.795e-03, 3.785e-03, 3.775e-03, + 3.765e-03, 3.755e-03, 3.746e-03, 3.736e-03, 3.726e-03, 3.716e-03, 3.707e-03, 3.697e-03, 3.687e-03, 3.678e-03, 3.668e-03, 3.659e-03, + 3.650e-03, 3.640e-03, 3.631e-03, 3.622e-03, 3.612e-03, 3.603e-03, 3.594e-03, 3.585e-03, 3.576e-03, 3.567e-03, 3.558e-03, 3.549e-03, + 3.541e-03, 3.532e-03, 3.514e-03, 3.497e-03, 3.480e-03, 3.463e-03, 3.446e-03, 3.430e-03, 3.413e-03, 3.397e-03, 3.381e-03, 3.365e-03, + 3.349e-03, 3.333e-03, 3.318e-03, 3.302e-03, 3.287e-03, 3.272e-03, 3.257e-03, 3.242e-03, 3.228e-03, 3.213e-03, 3.198e-03, 3.184e-03, + 3.170e-03, 3.156e-03, 3.142e-03, 3.108e-03, 3.074e-03, 3.041e-03, 3.009e-03, 2.978e-03, 2.947e-03, 2.917e-03, 2.887e-03, 2.858e-03, + 2.830e-03, 2.775e-03, 2.722e-03, 2.671e-03, 2.621e-03, 2.574e-03, 2.528e-03, 2.484e-03, 2.442e-03, 2.400e-03, 2.361e-03, 2.322e-03, + 2.285e-03, 2.249e-03, 2.214e-03, 3.542e-05, 1.969e-03, 1.841e-03}, + {0.0, 0.0, 6.802e-03, 6.681e-03, 6.565e-03, 6.453e-03, 6.344e-03, 6.239e-03, 6.138e-03, 6.040e-03, 5.944e-03, 5.852e-03, + 5.763e-03, 5.676e-03, 5.592e-03, 5.511e-03, 5.479e-03, 5.447e-03, 5.416e-03, 5.385e-03, 5.355e-03, 5.324e-03, 5.295e-03, 5.265e-03, + 5.236e-03, 5.207e-03, 5.178e-03, 5.150e-03, 5.122e-03, 5.095e-03, 5.081e-03, 5.067e-03, 5.054e-03, 5.040e-03, 5.027e-03, 5.014e-03, + 5.000e-03, 4.987e-03, 4.974e-03, 4.961e-03, 4.948e-03, 4.935e-03, 4.922e-03, 4.909e-03, 4.897e-03, 4.884e-03, 4.871e-03, 4.859e-03, + 4.846e-03, 4.834e-03, 4.822e-03, 4.809e-03, 4.797e-03, 4.785e-03, 4.773e-03, 4.761e-03, 4.749e-03, 4.737e-03, 4.725e-03, 4.714e-03, + 4.702e-03, 4.690e-03, 4.667e-03, 4.644e-03, 4.621e-03, 4.599e-03, 4.577e-03, 4.555e-03, 4.533e-03, 4.511e-03, 4.490e-03, 4.468e-03, + 4.447e-03, 4.427e-03, 4.406e-03, 4.385e-03, 4.365e-03, 4.345e-03, 4.325e-03, 4.306e-03, 4.286e-03, 4.267e-03, 4.247e-03, 4.228e-03, + 4.210e-03, 4.191e-03, 4.172e-03, 4.127e-03, 4.082e-03, 4.039e-03, 3.996e-03, 3.954e-03, 3.913e-03, 3.873e-03, 3.834e-03, 3.796e-03, + 3.758e-03, 3.685e-03, 3.614e-03, 3.546e-03, 3.481e-03, 3.418e-03, 3.357e-03, 3.299e-03, 3.242e-03, 3.188e-03, 3.135e-03, 3.084e-03, + 3.034e-03, 2.986e-03, 2.940e-03, 3.542e-05, 2.615e-03, 2.445e-03}, + {0.0, 0.0, 0.0, 9.407e-03, 9.243e-03, 9.084e-03, 8.931e-03, 8.783e-03, 8.640e-03, 8.502e-03, 8.368e-03, 8.238e-03, + 8.113e-03, 7.991e-03, 7.872e-03, 7.757e-03, 7.712e-03, 7.668e-03, 7.624e-03, 7.580e-03, 7.537e-03, 7.495e-03, 7.453e-03, 7.411e-03, + 7.370e-03, 7.330e-03, 7.289e-03, 7.250e-03, 7.210e-03, 7.172e-03, 7.152e-03, 7.133e-03, 7.114e-03, 7.095e-03, 7.076e-03, 7.057e-03, + 7.039e-03, 7.020e-03, 7.002e-03, 6.983e-03, 6.965e-03, 6.947e-03, 6.929e-03, 6.911e-03, 6.893e-03, 6.875e-03, 6.857e-03, 6.840e-03, + 6.822e-03, 6.805e-03, 6.787e-03, 6.770e-03, 6.753e-03, 6.736e-03, 6.719e-03, 6.702e-03, 6.685e-03, 6.668e-03, 6.651e-03, 6.635e-03, + 6.618e-03, 6.602e-03, 6.569e-03, 6.537e-03, 6.505e-03, 6.473e-03, 6.442e-03, 6.411e-03, 6.380e-03, 6.350e-03, 6.320e-03, 6.290e-03, + 6.260e-03, 6.231e-03, 6.202e-03, 6.173e-03, 6.144e-03, 6.116e-03, 6.088e-03, 6.060e-03, 6.033e-03, 6.006e-03, 5.979e-03, 5.952e-03, + 5.925e-03, 5.899e-03, 5.873e-03, 5.809e-03, 5.746e-03, 5.685e-03, 5.625e-03, 5.566e-03, 5.508e-03, 5.452e-03, 5.397e-03, 5.342e-03, + 5.289e-03, 5.186e-03, 5.087e-03, 4.992e-03, 4.900e-03, 4.811e-03, 4.726e-03, 4.643e-03, 4.564e-03, 4.487e-03, 4.412e-03, 4.340e-03, + 4.271e-03, 4.203e-03, 4.138e-03, 3.542e-05, 3.680e-03, 3.442e-03}, + {0.0, 0.0, 0.0, 0.0, 1.284e-02, 1.262e-02, 1.241e-02, 1.220e-02, 1.200e-02, 1.181e-02, 1.162e-02, 1.144e-02, + 1.127e-02, 1.110e-02, 1.093e-02, 1.078e-02, 1.071e-02, 1.065e-02, 1.059e-02, 1.053e-02, 1.047e-02, 1.041e-02, 1.035e-02, 1.029e-02, + 1.024e-02, 1.018e-02, 1.012e-02, 1.007e-02, 1.001e-02, 9.961e-03, 9.934e-03, 9.907e-03, 9.881e-03, 9.855e-03, 9.828e-03, 9.802e-03, + 9.776e-03, 9.750e-03, 9.725e-03, 9.699e-03, 9.674e-03, 9.649e-03, 9.623e-03, 9.598e-03, 9.574e-03, 9.549e-03, 9.524e-03, 9.500e-03, + 9.475e-03, 9.451e-03, 9.427e-03, 9.403e-03, 9.379e-03, 9.355e-03, 9.332e-03, 9.308e-03, 9.285e-03, 9.261e-03, 9.238e-03, 9.215e-03, + 9.192e-03, 9.170e-03, 9.124e-03, 9.079e-03, 9.035e-03, 8.991e-03, 8.947e-03, 8.904e-03, 8.862e-03, 8.819e-03, 8.777e-03, 8.736e-03, + 8.695e-03, 8.654e-03, 8.614e-03, 8.574e-03, 8.534e-03, 8.495e-03, 8.456e-03, 8.417e-03, 8.379e-03, 8.341e-03, 8.304e-03, 8.267e-03, + 8.230e-03, 8.193e-03, 8.157e-03, 8.068e-03, 7.981e-03, 7.896e-03, 7.812e-03, 7.731e-03, 7.651e-03, 7.572e-03, 7.495e-03, 7.420e-03, + 7.346e-03, 7.203e-03, 7.065e-03, 6.933e-03, 6.805e-03, 6.682e-03, 6.563e-03, 6.449e-03, 6.338e-03, 6.231e-03, 6.128e-03, 6.028e-03, + 5.931e-03, 5.838e-03, 5.747e-03, 3.542e-05, 5.111e-03, 4.781e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 1.731e-02, 1.702e-02, 1.674e-02, 1.646e-02, 1.620e-02, 1.594e-02, 1.570e-02, + 1.546e-02, 1.522e-02, 1.500e-02, 1.478e-02, 1.469e-02, 1.461e-02, 1.452e-02, 1.444e-02, 1.436e-02, 1.428e-02, 1.420e-02, 1.412e-02, + 1.404e-02, 1.396e-02, 1.389e-02, 1.381e-02, 1.374e-02, 1.366e-02, 1.362e-02, 1.359e-02, 1.355e-02, 1.352e-02, 1.348e-02, 1.344e-02, + 1.341e-02, 1.337e-02, 1.334e-02, 1.330e-02, 1.327e-02, 1.323e-02, 1.320e-02, 1.316e-02, 1.313e-02, 1.310e-02, 1.306e-02, 1.303e-02, + 1.300e-02, 1.296e-02, 1.293e-02, 1.290e-02, 1.286e-02, 1.283e-02, 1.280e-02, 1.277e-02, 1.273e-02, 1.270e-02, 1.267e-02, 1.264e-02, + 1.261e-02, 1.258e-02, 1.251e-02, 1.245e-02, 1.239e-02, 1.233e-02, 1.227e-02, 1.221e-02, 1.215e-02, 1.210e-02, 1.204e-02, 1.198e-02, + 1.192e-02, 1.187e-02, 1.181e-02, 1.176e-02, 1.170e-02, 1.165e-02, 1.160e-02, 1.154e-02, 1.149e-02, 1.144e-02, 1.139e-02, 1.134e-02, + 1.129e-02, 1.124e-02, 1.119e-02, 1.107e-02, 1.095e-02, 1.083e-02, 1.071e-02, 1.060e-02, 1.049e-02, 1.038e-02, 1.028e-02, 1.018e-02, + 1.007e-02, 9.879e-03, 9.690e-03, 9.508e-03, 9.333e-03, 9.164e-03, 9.001e-03, 8.844e-03, 8.692e-03, 8.546e-03, 8.404e-03, 8.267e-03, + 8.134e-03, 8.006e-03, 7.881e-03, 3.542e-05, 7.009e-03, 6.556e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.307e-02, 2.269e-02, 2.232e-02, 2.196e-02, 2.161e-02, 2.128e-02, + 2.095e-02, 2.063e-02, 2.033e-02, 2.003e-02, 1.991e-02, 1.980e-02, 1.968e-02, 1.957e-02, 1.946e-02, 1.935e-02, 1.924e-02, 1.913e-02, + 1.903e-02, 1.892e-02, 1.882e-02, 1.872e-02, 1.862e-02, 1.851e-02, 1.846e-02, 1.842e-02, 1.837e-02, 1.832e-02, 1.827e-02, 1.822e-02, + 1.817e-02, 1.812e-02, 1.808e-02, 1.803e-02, 1.798e-02, 1.793e-02, 1.789e-02, 1.784e-02, 1.779e-02, 1.775e-02, 1.770e-02, 1.766e-02, + 1.761e-02, 1.757e-02, 1.752e-02, 1.748e-02, 1.743e-02, 1.739e-02, 1.734e-02, 1.730e-02, 1.726e-02, 1.721e-02, 1.717e-02, 1.713e-02, + 1.708e-02, 1.704e-02, 1.696e-02, 1.687e-02, 1.679e-02, 1.671e-02, 1.663e-02, 1.655e-02, 1.647e-02, 1.639e-02, 1.631e-02, 1.624e-02, + 1.616e-02, 1.608e-02, 1.601e-02, 1.593e-02, 1.586e-02, 1.579e-02, 1.572e-02, 1.564e-02, 1.557e-02, 1.550e-02, 1.543e-02, 1.536e-02, + 1.530e-02, 1.523e-02, 1.516e-02, 1.499e-02, 1.483e-02, 1.467e-02, 1.452e-02, 1.437e-02, 1.422e-02, 1.407e-02, 1.393e-02, 1.379e-02, + 1.365e-02, 1.339e-02, 1.313e-02, 1.288e-02, 1.265e-02, 1.242e-02, 1.220e-02, 1.198e-02, 1.178e-02, 1.158e-02, 1.139e-02, 1.120e-02, + 1.102e-02, 1.085e-02, 1.068e-02, 3.542e-05, 9.498e-03, 8.884e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.042e-02, 2.992e-02, 2.943e-02, 2.897e-02, 2.851e-02, + 2.808e-02, 2.765e-02, 2.724e-02, 2.684e-02, 2.669e-02, 2.653e-02, 2.638e-02, 2.623e-02, 2.608e-02, 2.593e-02, 2.579e-02, 2.564e-02, + 2.550e-02, 2.536e-02, 2.522e-02, 2.508e-02, 2.494e-02, 2.481e-02, 2.474e-02, 2.468e-02, 2.461e-02, 2.454e-02, 2.448e-02, 2.441e-02, + 2.435e-02, 2.428e-02, 2.422e-02, 2.416e-02, 2.409e-02, 2.403e-02, 2.397e-02, 2.391e-02, 2.384e-02, 2.378e-02, 2.372e-02, 2.366e-02, + 2.360e-02, 2.354e-02, 2.348e-02, 2.342e-02, 2.336e-02, 2.330e-02, 2.324e-02, 2.318e-02, 2.312e-02, 2.306e-02, 2.301e-02, 2.295e-02, + 2.289e-02, 2.284e-02, 2.272e-02, 2.261e-02, 2.250e-02, 2.239e-02, 2.228e-02, 2.217e-02, 2.207e-02, 2.196e-02, 2.186e-02, 2.175e-02, + 2.165e-02, 2.155e-02, 2.145e-02, 2.135e-02, 2.125e-02, 2.115e-02, 2.106e-02, 2.096e-02, 2.087e-02, 2.077e-02, 2.068e-02, 2.059e-02, + 2.049e-02, 2.040e-02, 2.031e-02, 2.009e-02, 1.987e-02, 1.966e-02, 1.945e-02, 1.925e-02, 1.905e-02, 1.885e-02, 1.866e-02, 1.848e-02, + 1.829e-02, 1.794e-02, 1.759e-02, 1.726e-02, 1.694e-02, 1.664e-02, 1.634e-02, 1.606e-02, 1.578e-02, 1.552e-02, 1.526e-02, 1.501e-02, + 1.477e-02, 1.453e-02, 1.431e-02, 3.542e-05, 1.273e-02, 1.190e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.967e-02, 3.903e-02, 3.841e-02, 3.781e-02, + 3.723e-02, 3.666e-02, 3.612e-02, 3.559e-02, 3.538e-02, 3.518e-02, 3.497e-02, 3.477e-02, 3.457e-02, 3.438e-02, 3.419e-02, 3.399e-02, + 3.380e-02, 3.362e-02, 3.343e-02, 3.325e-02, 3.307e-02, 3.289e-02, 3.280e-02, 3.271e-02, 3.262e-02, 3.254e-02, 3.245e-02, 3.236e-02, + 3.228e-02, 3.219e-02, 3.211e-02, 3.202e-02, 3.194e-02, 3.186e-02, 3.177e-02, 3.169e-02, 3.161e-02, 3.153e-02, 3.144e-02, 3.136e-02, + 3.128e-02, 3.120e-02, 3.112e-02, 3.104e-02, 3.096e-02, 3.089e-02, 3.081e-02, 3.073e-02, 3.065e-02, 3.058e-02, 3.050e-02, 3.042e-02, + 3.035e-02, 3.027e-02, 3.012e-02, 2.997e-02, 2.983e-02, 2.968e-02, 2.954e-02, 2.939e-02, 2.925e-02, 2.911e-02, 2.897e-02, 2.884e-02, + 2.870e-02, 2.857e-02, 2.843e-02, 2.830e-02, 2.817e-02, 2.804e-02, 2.791e-02, 2.778e-02, 2.766e-02, 2.753e-02, 2.741e-02, 2.729e-02, + 2.716e-02, 2.704e-02, 2.692e-02, 2.663e-02, 2.634e-02, 2.606e-02, 2.579e-02, 2.552e-02, 2.525e-02, 2.499e-02, 2.474e-02, 2.449e-02, + 2.425e-02, 2.377e-02, 2.332e-02, 2.288e-02, 2.246e-02, 2.205e-02, 2.166e-02, 2.128e-02, 2.092e-02, 2.057e-02, 2.022e-02, 1.989e-02, + 1.957e-02, 1.927e-02, 1.897e-02, 3.542e-05, 1.687e-02, 1.578e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.124e-02, 5.042e-02, 4.963e-02, + 4.887e-02, 4.812e-02, 4.741e-02, 4.671e-02, 4.644e-02, 4.617e-02, 4.590e-02, 4.564e-02, 4.537e-02, 4.512e-02, 4.486e-02, 4.461e-02, + 4.436e-02, 4.412e-02, 4.387e-02, 4.363e-02, 4.340e-02, 4.316e-02, 4.304e-02, 4.293e-02, 4.281e-02, 4.270e-02, 4.258e-02, 4.247e-02, + 4.236e-02, 4.225e-02, 4.213e-02, 4.202e-02, 4.191e-02, 4.180e-02, 4.169e-02, 4.158e-02, 4.148e-02, 4.137e-02, 4.126e-02, 4.116e-02, + 4.105e-02, 4.094e-02, 4.084e-02, 4.073e-02, 4.063e-02, 4.053e-02, 4.043e-02, 4.032e-02, 4.022e-02, 4.012e-02, 4.002e-02, 3.992e-02, + 3.982e-02, 3.972e-02, 3.952e-02, 3.933e-02, 3.914e-02, 3.895e-02, 3.876e-02, 3.857e-02, 3.838e-02, 3.820e-02, 3.802e-02, 3.784e-02, + 3.766e-02, 3.748e-02, 3.731e-02, 3.713e-02, 3.696e-02, 3.679e-02, 3.662e-02, 3.646e-02, 3.629e-02, 3.613e-02, 3.596e-02, 3.580e-02, + 3.564e-02, 3.548e-02, 3.533e-02, 3.494e-02, 3.456e-02, 3.419e-02, 3.383e-02, 3.348e-02, 3.313e-02, 3.279e-02, 3.246e-02, 3.213e-02, + 3.181e-02, 3.119e-02, 3.059e-02, 3.002e-02, 2.947e-02, 2.893e-02, 2.842e-02, 2.792e-02, 2.744e-02, 2.698e-02, 2.653e-02, 2.610e-02, + 2.568e-02, 2.528e-02, 2.488e-02, 3.542e-05, 2.213e-02, 2.070e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.556e-02, 6.453e-02, + 6.353e-02, 6.256e-02, 6.163e-02, 6.072e-02, 6.036e-02, 6.001e-02, 5.966e-02, 5.932e-02, 5.898e-02, 5.864e-02, 5.831e-02, 5.799e-02, + 5.766e-02, 5.734e-02, 5.702e-02, 5.671e-02, 5.640e-02, 5.610e-02, 5.594e-02, 5.579e-02, 5.564e-02, 5.549e-02, 5.535e-02, 5.520e-02, + 5.505e-02, 5.490e-02, 5.476e-02, 5.461e-02, 5.447e-02, 5.433e-02, 5.419e-02, 5.404e-02, 5.390e-02, 5.376e-02, 5.362e-02, 5.349e-02, + 5.335e-02, 5.321e-02, 5.307e-02, 5.294e-02, 5.280e-02, 5.267e-02, 5.254e-02, 5.240e-02, 5.227e-02, 5.214e-02, 5.201e-02, 5.188e-02, + 5.175e-02, 5.162e-02, 5.136e-02, 5.111e-02, 5.086e-02, 5.061e-02, 5.036e-02, 5.012e-02, 4.988e-02, 4.964e-02, 4.940e-02, 4.917e-02, + 4.894e-02, 4.871e-02, 4.848e-02, 4.825e-02, 4.803e-02, 4.781e-02, 4.759e-02, 4.737e-02, 4.716e-02, 4.694e-02, 4.673e-02, 4.652e-02, + 4.632e-02, 4.611e-02, 4.591e-02, 4.540e-02, 4.491e-02, 4.443e-02, 4.396e-02, 4.350e-02, 4.305e-02, 4.261e-02, 4.218e-02, 4.175e-02, + 4.134e-02, 4.053e-02, 3.975e-02, 3.901e-02, 3.829e-02, 3.759e-02, 3.693e-02, 3.628e-02, 3.566e-02, 3.506e-02, 3.448e-02, 3.391e-02, + 3.337e-02, 3.284e-02, 3.233e-02, 3.542e-05, 2.875e-02, 2.689e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.315e-02, + 8.185e-02, 8.060e-02, 7.939e-02, 7.821e-02, 7.775e-02, 7.730e-02, 7.685e-02, 7.641e-02, 7.597e-02, 7.553e-02, 7.511e-02, 7.468e-02, + 7.426e-02, 7.385e-02, 7.344e-02, 7.304e-02, 7.264e-02, 7.224e-02, 7.205e-02, 7.185e-02, 7.166e-02, 7.147e-02, 7.128e-02, 7.108e-02, + 7.090e-02, 7.071e-02, 7.052e-02, 7.033e-02, 7.015e-02, 6.996e-02, 6.978e-02, 6.960e-02, 6.942e-02, 6.923e-02, 6.906e-02, 6.888e-02, + 6.870e-02, 6.852e-02, 6.835e-02, 6.817e-02, 6.800e-02, 6.782e-02, 6.765e-02, 6.748e-02, 6.731e-02, 6.714e-02, 6.697e-02, 6.680e-02, + 6.664e-02, 6.647e-02, 6.614e-02, 6.581e-02, 6.549e-02, 6.517e-02, 6.485e-02, 6.454e-02, 6.423e-02, 6.392e-02, 6.361e-02, 6.331e-02, + 6.301e-02, 6.272e-02, 6.242e-02, 6.213e-02, 6.185e-02, 6.156e-02, 6.128e-02, 6.100e-02, 6.072e-02, 6.044e-02, 6.017e-02, 5.990e-02, + 5.963e-02, 5.937e-02, 5.911e-02, 5.846e-02, 5.783e-02, 5.721e-02, 5.660e-02, 5.601e-02, 5.543e-02, 5.486e-02, 5.430e-02, 5.375e-02, + 5.322e-02, 5.218e-02, 5.118e-02, 5.022e-02, 4.929e-02, 4.840e-02, 4.754e-02, 4.671e-02, 4.591e-02, 4.513e-02, 4.438e-02, 4.366e-02, + 4.296e-02, 4.228e-02, 4.162e-02, 3.542e-05, 3.701e-02, 3.462e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.10460, 0.10290, 0.10140, 9.988e-02, 9.929e-02, 9.871e-02, 9.813e-02, 9.757e-02, 9.700e-02, 9.645e-02, 9.590e-02, 9.536e-02, + 9.482e-02, 9.430e-02, 9.377e-02, 9.325e-02, 9.274e-02, 9.224e-02, 9.199e-02, 9.174e-02, 9.149e-02, 9.124e-02, 9.100e-02, 9.075e-02, + 9.051e-02, 9.027e-02, 9.003e-02, 8.979e-02, 8.955e-02, 8.932e-02, 8.908e-02, 8.885e-02, 8.862e-02, 8.839e-02, 8.816e-02, 8.793e-02, + 8.770e-02, 8.747e-02, 8.725e-02, 8.703e-02, 8.680e-02, 8.658e-02, 8.636e-02, 8.614e-02, 8.592e-02, 8.571e-02, 8.549e-02, 8.528e-02, + 8.506e-02, 8.485e-02, 8.443e-02, 8.401e-02, 8.360e-02, 8.319e-02, 8.278e-02, 8.238e-02, 8.198e-02, 8.159e-02, 8.120e-02, 8.081e-02, + 8.043e-02, 8.005e-02, 7.968e-02, 7.931e-02, 7.894e-02, 7.857e-02, 7.821e-02, 7.786e-02, 7.750e-02, 7.715e-02, 7.680e-02, 7.646e-02, + 7.611e-02, 7.578e-02, 7.544e-02, 7.461e-02, 7.380e-02, 7.301e-02, 7.224e-02, 7.148e-02, 7.074e-02, 7.001e-02, 6.930e-02, 6.860e-02, + 6.792e-02, 6.659e-02, 6.532e-02, 6.409e-02, 6.291e-02, 6.177e-02, 6.067e-02, 5.961e-02, 5.859e-02, 5.760e-02, 5.664e-02, 5.572e-02, + 5.482e-02, 5.395e-02, 5.312e-02, 3.542e-05, 4.724e-02, 4.418e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.13040, 0.12840, 0.12650, 0.12580, 0.125, 0.12430, 0.12360, 0.12290, 0.12220, 0.12150, 0.12080, + 0.12010, 0.11940, 0.11870, 0.11810, 0.11740, 0.11680, 0.11650, 0.11620, 0.11580, 0.11550, 0.11520, 0.11490, + 0.11460, 0.11430, 0.114, 0.11370, 0.11340, 0.11310, 0.11280, 0.11250, 0.11220, 0.11190, 0.11160, 0.11130, + 0.111, 0.11080, 0.11050, 0.11020, 0.10990, 0.10960, 0.10930, 0.10910, 0.10880, 0.10850, 0.10820, 0.108, + 0.10770, 0.10740, 0.10690, 0.10640, 0.10580, 0.10530, 0.10480, 0.10430, 0.10380, 0.10330, 0.10280, 0.10230, + 0.10180, 0.10130, 0.10090, 0.10040, 9.993e-02, 9.946e-02, 9.901e-02, 9.855e-02, 9.810e-02, 9.766e-02, 9.722e-02, 9.678e-02, + 9.635e-02, 9.592e-02, 9.549e-02, 9.444e-02, 9.342e-02, 9.242e-02, 9.144e-02, 9.048e-02, 8.954e-02, 8.862e-02, 8.771e-02, 8.683e-02, + 8.597e-02, 8.429e-02, 8.267e-02, 8.112e-02, 7.962e-02, 7.818e-02, 7.678e-02, 7.544e-02, 7.415e-02, 7.289e-02, 7.168e-02, 7.051e-02, + 6.938e-02, 6.828e-02, 6.722e-02, 3.542e-05, 5.978e-02, 5.591e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.16150, 0.159, 0.15810, 0.15710, 0.15620, 0.15530, 0.15440, 0.15350, 0.15260, 0.15180, + 0.15090, 0.15, 0.14920, 0.14840, 0.14760, 0.14670, 0.14630, 0.14590, 0.14550, 0.14520, 0.14480, 0.14440, + 0.144, 0.14360, 0.14320, 0.14280, 0.14250, 0.14210, 0.14170, 0.14130, 0.141, 0.14060, 0.14020, 0.13990, + 0.13950, 0.13910, 0.13880, 0.13840, 0.13810, 0.13770, 0.13730, 0.137, 0.13660, 0.13630, 0.136, 0.13560, + 0.13530, 0.13490, 0.13430, 0.13360, 0.13290, 0.13230, 0.13160, 0.131, 0.13040, 0.12970, 0.12910, 0.12850, + 0.12790, 0.12730, 0.12670, 0.12610, 0.12550, 0.12490, 0.12430, 0.12380, 0.12320, 0.12260, 0.12210, 0.12150, + 0.121, 0.12050, 0.11990, 0.11860, 0.11730, 0.11610, 0.11480, 0.11360, 0.11240, 0.11130, 0.11010, 0.109, + 0.10790, 0.10580, 0.10380, 0.10190, 9.997e-02, 9.816e-02, 9.641e-02, 9.473e-02, 9.310e-02, 9.152e-02, 9.000e-02, 8.853e-02, + 8.711e-02, 8.573e-02, 8.440e-02, 3.542e-05, 7.505e-02, 7.019e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.19840, 0.19720, 0.19610, 0.19490, 0.19370, 0.19260, 0.19150, 0.19040, 0.18930, 0.18820, 0.18720, + 0.18610, 0.18510, 0.184, 0.183, 0.18250, 0.182, 0.18150, 0.181, 0.18050, 0.18, 0.17960, 0.17910, 0.17860, + 0.17810, 0.17760, 0.17720, 0.17670, 0.17620, 0.17580, 0.17530, 0.17480, 0.17440, 0.17390, 0.17350, 0.173, 0.17260, + 0.17210, 0.17170, 0.17120, 0.17080, 0.17040, 0.16990, 0.16950, 0.16910, 0.16870, 0.16820, 0.16740, 0.16660, 0.16570, + 0.16490, 0.16410, 0.16330, 0.16250, 0.16170, 0.16090, 0.16020, 0.15940, 0.15870, 0.15790, 0.15720, 0.15640, 0.15570, + 0.155, 0.15430, 0.15360, 0.15290, 0.15220, 0.15150, 0.15080, 0.15010, 0.14950, 0.14780, 0.14620, 0.14460, 0.14310, + 0.14160, 0.14010, 0.13870, 0.13730, 0.13590, 0.13450, 0.13190, 0.12940, 0.12690, 0.12460, 0.12230, 0.12010, 0.118, + 0.116, 0.11410, 0.11220, 0.11030, 0.10850, 0.10680, 0.10520, 3.542e-05, 9.352e-02, 8.746e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.21510, 0.21380, 0.21250, 0.21130, 0.21, 0.20880, 0.20760, 0.20640, 0.20520, 0.204, 0.20290, 0.20180, 0.20060, 0.19950, + 0.199, 0.19840, 0.19790, 0.19730, 0.19680, 0.19630, 0.19570, 0.19520, 0.19470, 0.19420, 0.19360, 0.19310, 0.19260, 0.19210, 0.19160, + 0.19110, 0.19060, 0.19010, 0.18960, 0.18910, 0.18860, 0.18810, 0.18760, 0.18720, 0.18670, 0.18620, 0.18570, 0.18520, 0.18480, 0.18430, + 0.18380, 0.18340, 0.18250, 0.18150, 0.18060, 0.17980, 0.17890, 0.178, 0.17710, 0.17630, 0.17540, 0.17460, 0.17380, 0.17290, 0.17210, + 0.17130, 0.17050, 0.16970, 0.16890, 0.16820, 0.16740, 0.16660, 0.16590, 0.16510, 0.16440, 0.16360, 0.16290, 0.16110, 0.15940, 0.15770, + 0.156, 0.15430, 0.15270, 0.15110, 0.14960, 0.14810, 0.14660, 0.14370, 0.141, 0.13830, 0.13580, 0.13330, 0.13090, 0.12860, 0.12640, + 0.12430, 0.12220, 0.12020, 0.11830, 0.11640, 0.11460, 3.542e-05, 0.10190, 9.531e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.23290, 0.23150, 0.23010, 0.22870, 0.22740, 0.22610, 0.22480, 0.22350, 0.22220, 0.221, 0.21970, 0.21850, 0.21730, + 0.21670, 0.21610, 0.21550, 0.21490, 0.21430, 0.21370, 0.21310, 0.21260, 0.212, 0.21140, 0.21090, 0.21030, 0.20970, 0.20920, 0.20860, + 0.20810, 0.20750, 0.207, 0.20640, 0.20590, 0.20540, 0.20480, 0.20430, 0.20380, 0.20330, 0.20270, 0.20220, 0.20170, 0.20120, 0.20070, + 0.20020, 0.19970, 0.19870, 0.19770, 0.19670, 0.19570, 0.19480, 0.19380, 0.19290, 0.19190, 0.191, 0.19010, 0.18920, 0.18830, 0.18740, + 0.18650, 0.18560, 0.18480, 0.18390, 0.18310, 0.18220, 0.18140, 0.18060, 0.17980, 0.179, 0.17820, 0.17740, 0.17540, 0.17350, 0.17160, + 0.16980, 0.168, 0.16630, 0.16450, 0.16290, 0.16120, 0.15960, 0.15650, 0.15350, 0.15060, 0.14780, 0.14510, 0.14250, 0.14, 0.13760, + 0.13530, 0.133, 0.13090, 0.12880, 0.12670, 0.12480, 3.542e-05, 0.11090, 0.1037}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.25180, 0.25030, 0.24890, 0.24740, 0.246, 0.24450, 0.24310, 0.24170, 0.24040, 0.239, 0.23770, 0.23640, + 0.23570, 0.23510, 0.23440, 0.23380, 0.23310, 0.23250, 0.23190, 0.23120, 0.23060, 0.23, 0.22940, 0.22880, 0.22810, 0.22750, 0.22690, + 0.22630, 0.22570, 0.22510, 0.22460, 0.224, 0.22340, 0.22280, 0.22220, 0.22160, 0.22110, 0.22050, 0.21990, 0.21940, 0.21880, 0.21830, + 0.21770, 0.21720, 0.21610, 0.215, 0.21390, 0.21290, 0.21180, 0.21080, 0.20970, 0.20870, 0.20770, 0.20670, 0.20570, 0.20480, 0.20380, + 0.20280, 0.20190, 0.201, 0.2, 0.19910, 0.19820, 0.19730, 0.19640, 0.19550, 0.19460, 0.19370, 0.19290, 0.19080, 0.18870, 0.18660, + 0.18470, 0.18270, 0.18080, 0.17890, 0.17710, 0.17530, 0.17360, 0.17020, 0.16690, 0.16370, 0.16070, 0.15780, 0.155, 0.15230, 0.14960, + 0.14710, 0.14470, 0.14230, 0.14, 0.13780, 0.13560, 3.542e-05, 0.12060, 0.1128}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.27210, 0.27050, 0.26890, 0.26730, 0.26580, 0.26420, 0.26270, 0.26120, 0.25970, 0.25830, 0.25680, + 0.25610, 0.25540, 0.25470, 0.254, 0.25330, 0.25260, 0.25190, 0.25130, 0.25060, 0.24990, 0.24920, 0.24860, 0.24790, 0.24720, 0.24660, + 0.24590, 0.24530, 0.24460, 0.244, 0.24330, 0.24270, 0.24210, 0.24140, 0.24080, 0.24020, 0.23960, 0.239, 0.23840, 0.23770, 0.23710, + 0.23650, 0.23590, 0.23480, 0.23360, 0.23240, 0.23130, 0.23010, 0.229, 0.22790, 0.22680, 0.22570, 0.22460, 0.22350, 0.22250, 0.22140, + 0.22040, 0.21930, 0.21830, 0.21730, 0.21630, 0.21530, 0.21430, 0.21330, 0.21240, 0.21140, 0.21050, 0.20950, 0.20720, 0.205, 0.20270, + 0.20060, 0.19850, 0.19640, 0.19440, 0.19240, 0.19040, 0.18850, 0.18480, 0.18130, 0.17790, 0.17460, 0.17140, 0.16830, 0.16540, 0.16250, + 0.15980, 0.15710, 0.15460, 0.15210, 0.14970, 0.14730, 3.542e-05, 0.131, 0.1225}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.29370, 0.29190, 0.29020, 0.28850, 0.28690, 0.28520, 0.28360, 0.282, 0.28040, 0.27880, + 0.278, 0.27730, 0.27650, 0.27570, 0.275, 0.27420, 0.27350, 0.27270, 0.272, 0.27130, 0.27050, 0.26980, 0.26910, 0.26840, 0.26760, + 0.26690, 0.26620, 0.26550, 0.26480, 0.26410, 0.26340, 0.26280, 0.26210, 0.26140, 0.26070, 0.26, 0.25940, 0.25870, 0.258, 0.25740, + 0.25670, 0.25610, 0.25480, 0.25350, 0.25220, 0.251, 0.24980, 0.24850, 0.24730, 0.24610, 0.24490, 0.24370, 0.24260, 0.24140, 0.24030, + 0.23910, 0.238, 0.23690, 0.23580, 0.23470, 0.23360, 0.23260, 0.23150, 0.23050, 0.22940, 0.22840, 0.22740, 0.22490, 0.22240, 0.22, + 0.21770, 0.21540, 0.21310, 0.21090, 0.20880, 0.20660, 0.20460, 0.20060, 0.19670, 0.193, 0.18940, 0.186, 0.18270, 0.17950, 0.17640, + 0.17340, 0.17050, 0.16770, 0.165, 0.16240, 0.15990, 3.542e-05, 0.14210, 0.1329}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31660, 0.31480, 0.31290, 0.31110, 0.30930, 0.30760, 0.30580, 0.30410, 0.30240, + 0.30150, 0.30070, 0.29990, 0.299, 0.29820, 0.29740, 0.29660, 0.29580, 0.295, 0.29420, 0.29340, 0.29260, 0.29180, 0.291, 0.29020, + 0.28940, 0.28870, 0.28790, 0.28720, 0.28640, 0.28560, 0.28490, 0.28420, 0.28340, 0.28270, 0.282, 0.28120, 0.28050, 0.27980, 0.27910, + 0.27840, 0.27760, 0.27620, 0.27490, 0.27350, 0.27210, 0.27080, 0.26940, 0.26810, 0.26680, 0.26550, 0.26430, 0.263, 0.26170, 0.26050, + 0.25930, 0.258, 0.25680, 0.25560, 0.25450, 0.25330, 0.25210, 0.251, 0.24980, 0.24870, 0.24760, 0.24650, 0.24380, 0.24110, 0.23850, + 0.23590, 0.23350, 0.231, 0.22860, 0.22630, 0.224, 0.22170, 0.21740, 0.21320, 0.20920, 0.20530, 0.20160, 0.198, 0.19450, 0.19120, + 0.18790, 0.18480, 0.18180, 0.17880, 0.176, 0.17330, 3.542e-05, 0.154, 0.1441}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.34110, 0.33910, 0.33710, 0.33520, 0.33320, 0.33130, 0.32940, 0.32760, + 0.32670, 0.32580, 0.32490, 0.324, 0.32310, 0.32220, 0.32130, 0.32040, 0.31950, 0.31870, 0.31780, 0.31690, 0.31610, 0.31520, 0.31440, + 0.31350, 0.31270, 0.31190, 0.31110, 0.31020, 0.30940, 0.30860, 0.30780, 0.307, 0.30620, 0.30540, 0.30460, 0.30380, 0.30310, 0.30230, + 0.30150, 0.30070, 0.29920, 0.29770, 0.29620, 0.29470, 0.29330, 0.29180, 0.29040, 0.289, 0.28760, 0.28620, 0.28480, 0.28350, 0.28210, + 0.28080, 0.27950, 0.27820, 0.27690, 0.27560, 0.27430, 0.27310, 0.27180, 0.27060, 0.26930, 0.26810, 0.26690, 0.264, 0.26110, 0.25830, + 0.25550, 0.25280, 0.25020, 0.24760, 0.245, 0.24260, 0.24010, 0.23540, 0.23090, 0.22650, 0.22230, 0.21830, 0.21440, 0.21060, 0.207, + 0.20350, 0.20010, 0.19680, 0.19360, 0.19060, 0.18760, 3.542e-05, 0.16680, 0.156}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.36710, 0.36490, 0.36280, 0.36070, 0.35860, 0.35660, 0.35460, + 0.35360, 0.35260, 0.35160, 0.35060, 0.34960, 0.34870, 0.34770, 0.34680, 0.34580, 0.34490, 0.34390, 0.343, 0.34210, 0.34110, 0.34020, + 0.33930, 0.33840, 0.33750, 0.33660, 0.33570, 0.33480, 0.334, 0.33310, 0.33220, 0.33130, 0.33050, 0.32960, 0.32880, 0.32790, 0.32710, + 0.32630, 0.32540, 0.32380, 0.32210, 0.32050, 0.31890, 0.31730, 0.31580, 0.31420, 0.31270, 0.31120, 0.30970, 0.30820, 0.30670, 0.30520, + 0.30380, 0.30240, 0.30090, 0.29950, 0.29820, 0.29680, 0.29540, 0.29410, 0.29270, 0.29140, 0.29010, 0.28880, 0.28560, 0.28250, 0.27940, + 0.27640, 0.27350, 0.27060, 0.26780, 0.26510, 0.26240, 0.25980, 0.25460, 0.24970, 0.245, 0.24050, 0.23610, 0.23190, 0.22780, 0.22390, + 0.22010, 0.21640, 0.21290, 0.20940, 0.20610, 0.20290, 3.542e-05, 0.18040, 0.1687}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.39460, 0.39230, 0.39010, 0.38780, 0.38560, 0.38340, + 0.38230, 0.38120, 0.38020, 0.37910, 0.37810, 0.377, 0.376, 0.37490, 0.37390, 0.37290, 0.37190, 0.37080, 0.36980, 0.36880, 0.36780, + 0.36690, 0.36590, 0.36490, 0.36390, 0.363, 0.362, 0.361, 0.36010, 0.35920, 0.35820, 0.35730, 0.35640, 0.35540, 0.35450, 0.35360, + 0.35270, 0.35180, 0.35, 0.34820, 0.34650, 0.34470, 0.343, 0.34130, 0.33970, 0.338, 0.33640, 0.33470, 0.33310, 0.33150, 0.32990, + 0.32840, 0.32680, 0.32530, 0.32380, 0.32230, 0.32080, 0.31930, 0.31780, 0.31640, 0.315, 0.31350, 0.31210, 0.30870, 0.30530, 0.302, + 0.29870, 0.29560, 0.29250, 0.28940, 0.28650, 0.28360, 0.28070, 0.27520, 0.26990, 0.26480, 0.25990, 0.25510, 0.25060, 0.24620, 0.24190, + 0.23780, 0.23390, 0.23, 0.22630, 0.22270, 0.21930, 3.542e-05, 0.19490, 0.1823}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42390, 0.42140, 0.419, 0.41660, 0.41420, + 0.413, 0.41190, 0.41070, 0.40960, 0.40840, 0.40730, 0.40610, 0.405, 0.40390, 0.40280, 0.40170, 0.40060, 0.39950, 0.39840, 0.39730, + 0.39630, 0.39520, 0.39410, 0.39310, 0.392, 0.391, 0.39, 0.38890, 0.38790, 0.38690, 0.38590, 0.38490, 0.38390, 0.38290, 0.38190, + 0.38090, 0.37990, 0.378, 0.37610, 0.37420, 0.37230, 0.37050, 0.36860, 0.36680, 0.365, 0.36320, 0.36150, 0.35970, 0.358, 0.35630, + 0.35460, 0.35290, 0.35130, 0.34960, 0.348, 0.34640, 0.34480, 0.34320, 0.34160, 0.34010, 0.33860, 0.337, 0.33330, 0.32960, 0.32610, + 0.32260, 0.31910, 0.31580, 0.31250, 0.30930, 0.30620, 0.30310, 0.29710, 0.29140, 0.28590, 0.28060, 0.27540, 0.27050, 0.26580, 0.26120, + 0.25680, 0.25250, 0.24830, 0.24430, 0.24050, 0.23670, 3.542e-05, 0.21040, 0.1968}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.45490, 0.45230, 0.44970, 0.44710, + 0.44580, 0.44450, 0.44330, 0.442, 0.44080, 0.43960, 0.43830, 0.43710, 0.43590, 0.43470, 0.43350, 0.43230, 0.43110, 0.43, 0.42880, + 0.42760, 0.42650, 0.42530, 0.42420, 0.42310, 0.42190, 0.42080, 0.41970, 0.41860, 0.41750, 0.41640, 0.41530, 0.41420, 0.41320, 0.41210, + 0.411, 0.41, 0.40790, 0.40580, 0.40380, 0.40170, 0.39970, 0.39770, 0.39580, 0.39380, 0.39190, 0.39, 0.38810, 0.38620, 0.38440, + 0.38260, 0.38080, 0.379, 0.37720, 0.37540, 0.37370, 0.372, 0.37030, 0.36860, 0.36690, 0.36520, 0.36360, 0.35950, 0.35560, 0.35170, + 0.34790, 0.34420, 0.34060, 0.33710, 0.33360, 0.33020, 0.32690, 0.32050, 0.31430, 0.30830, 0.30260, 0.29710, 0.29180, 0.28660, 0.28170, + 0.27690, 0.27230, 0.26780, 0.26350, 0.25930, 0.25530, 3.542e-05, 0.22690, 0.2122}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.48780, 0.48490, 0.48210, + 0.48080, 0.47940, 0.478, 0.47670, 0.47530, 0.474, 0.47270, 0.47130, 0.47, 0.46870, 0.46740, 0.46620, 0.46490, 0.46360, 0.46230, + 0.46110, 0.45980, 0.45860, 0.45740, 0.45610, 0.45490, 0.45370, 0.45250, 0.45130, 0.45010, 0.44890, 0.44780, 0.44660, 0.44540, 0.44430, + 0.44310, 0.442, 0.43970, 0.43750, 0.43530, 0.43310, 0.43090, 0.42870, 0.42660, 0.42450, 0.42240, 0.42040, 0.41830, 0.41630, 0.41430, + 0.41240, 0.41040, 0.40850, 0.40650, 0.40460, 0.40280, 0.40090, 0.39910, 0.39720, 0.39540, 0.39360, 0.39190, 0.38750, 0.38320, 0.37910, + 0.375, 0.371, 0.36710, 0.36330, 0.35950, 0.35590, 0.35230, 0.34530, 0.33870, 0.33230, 0.32610, 0.32010, 0.31440, 0.30890, 0.30350, + 0.29840, 0.29340, 0.28860, 0.28390, 0.27940, 0.27510, 3.542e-05, 0.24450, 0.2287}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.52250, 0.51950, + 0.518, 0.51650, 0.51510, 0.51360, 0.51210, 0.51070, 0.50920, 0.50780, 0.50640, 0.505, 0.50360, 0.50220, 0.50080, 0.49940, 0.49810, + 0.49670, 0.49540, 0.494, 0.49270, 0.49140, 0.49010, 0.48870, 0.48740, 0.48610, 0.48490, 0.48360, 0.48230, 0.481, 0.47980, 0.47850, + 0.47730, 0.47610, 0.47360, 0.47120, 0.46880, 0.46640, 0.46410, 0.46180, 0.45950, 0.45720, 0.455, 0.45270, 0.45050, 0.44840, 0.44620, + 0.44410, 0.442, 0.43990, 0.43780, 0.43580, 0.43370, 0.43170, 0.42970, 0.42780, 0.42580, 0.42390, 0.422, 0.41730, 0.41270, 0.40820, + 0.40380, 0.39950, 0.39530, 0.39110, 0.38710, 0.38320, 0.37930, 0.37180, 0.36460, 0.35770, 0.35110, 0.34460, 0.33850, 0.33250, 0.32680, + 0.32120, 0.31590, 0.31070, 0.30570, 0.30080, 0.29610, 3.542e-05, 0.26320, 0.2461}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.55930, + 0.55770, 0.55610, 0.55450, 0.55290, 0.55130, 0.54980, 0.54820, 0.54670, 0.54510, 0.54360, 0.54210, 0.54060, 0.53910, 0.53760, 0.53610, + 0.53460, 0.53320, 0.53170, 0.53030, 0.52890, 0.52740, 0.526, 0.52460, 0.52320, 0.52180, 0.52050, 0.51910, 0.51770, 0.51640, 0.515, + 0.51370, 0.51230, 0.50970, 0.50710, 0.50450, 0.50190, 0.49940, 0.49690, 0.49440, 0.492, 0.48960, 0.48720, 0.48480, 0.48240, 0.48010, + 0.47780, 0.47550, 0.47330, 0.47110, 0.46880, 0.46670, 0.46450, 0.46230, 0.46020, 0.45810, 0.456, 0.454, 0.44890, 0.44390, 0.43910, + 0.43440, 0.42970, 0.42520, 0.42080, 0.41640, 0.41220, 0.408, 0.4, 0.39220, 0.38480, 0.37760, 0.37070, 0.36410, 0.35760, 0.35150, + 0.34550, 0.33970, 0.33410, 0.32870, 0.32350, 0.31850, 3.542e-05, 0.28310, 0.2647}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.57850, 0.57680, 0.57510, 0.57350, 0.57180, 0.57020, 0.56860, 0.567, 0.56540, 0.56380, 0.56220, 0.56070, 0.55910, 0.55760, 0.556, + 0.55450, 0.553, 0.55150, 0.55, 0.54850, 0.547, 0.54550, 0.54410, 0.54260, 0.54120, 0.53980, 0.53830, 0.53690, 0.53550, 0.53410, + 0.53270, 0.53130, 0.52860, 0.52590, 0.52320, 0.52050, 0.51790, 0.51530, 0.51270, 0.51020, 0.50770, 0.50520, 0.50270, 0.50030, 0.49790, + 0.49550, 0.49310, 0.49080, 0.48850, 0.48620, 0.48390, 0.48160, 0.47940, 0.47720, 0.475, 0.47290, 0.47070, 0.46550, 0.46030, 0.45530, + 0.45040, 0.44560, 0.44090, 0.43630, 0.43180, 0.42740, 0.423, 0.41470, 0.40660, 0.39890, 0.39150, 0.38430, 0.37740, 0.37080, 0.36440, + 0.35820, 0.35220, 0.34640, 0.34080, 0.33540, 0.33020, 3.542e-05, 0.29350, 0.2744}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.59820, 0.59640, 0.59470, 0.593, 0.59130, 0.58960, 0.588, 0.58630, 0.58470, 0.583, 0.58140, 0.57980, 0.57820, 0.57660, + 0.575, 0.57340, 0.57180, 0.57030, 0.56870, 0.56720, 0.56570, 0.56420, 0.56270, 0.56120, 0.55970, 0.55820, 0.55670, 0.55520, 0.55380, + 0.55230, 0.55090, 0.548, 0.54520, 0.54240, 0.53970, 0.53690, 0.53420, 0.53160, 0.52890, 0.52630, 0.52370, 0.52120, 0.51870, 0.51620, + 0.51370, 0.51120, 0.50880, 0.50640, 0.504, 0.50170, 0.49930, 0.497, 0.49470, 0.49250, 0.49020, 0.488, 0.48250, 0.47720, 0.472, + 0.46690, 0.46190, 0.457, 0.45220, 0.44760, 0.443, 0.43850, 0.42980, 0.42150, 0.41350, 0.40580, 0.39840, 0.39120, 0.38430, 0.37770, + 0.37130, 0.36510, 0.35910, 0.35330, 0.34760, 0.34220, 3.542e-05, 0.30420, 0.2844}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.61840, 0.61660, 0.61480, 0.61310, 0.61130, 0.60960, 0.60790, 0.60620, 0.60450, 0.60280, 0.60110, 0.59940, 0.59780, + 0.59610, 0.59450, 0.59280, 0.59120, 0.58960, 0.588, 0.58640, 0.58490, 0.58330, 0.58170, 0.58020, 0.57860, 0.57710, 0.57560, 0.57410, + 0.57260, 0.57110, 0.56810, 0.56520, 0.56230, 0.55940, 0.55660, 0.55380, 0.551, 0.54830, 0.54560, 0.54290, 0.54020, 0.53760, 0.535, + 0.53240, 0.52990, 0.52740, 0.52490, 0.52240, 0.52, 0.51750, 0.51510, 0.51280, 0.51040, 0.50810, 0.50580, 0.50010, 0.49460, 0.48920, + 0.48390, 0.47870, 0.47360, 0.46870, 0.46390, 0.45910, 0.45450, 0.44550, 0.43680, 0.42850, 0.42050, 0.41290, 0.40540, 0.39830, 0.39140, + 0.38470, 0.37830, 0.37210, 0.36610, 0.36030, 0.35460, 3.542e-05, 0.31520, 0.2948}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.63920, 0.63740, 0.63550, 0.63370, 0.63190, 0.63010, 0.62830, 0.62660, 0.62480, 0.623, 0.62130, 0.61960, + 0.61790, 0.61620, 0.61450, 0.61280, 0.61110, 0.60950, 0.60780, 0.60620, 0.60460, 0.60290, 0.60130, 0.59970, 0.59810, 0.59660, 0.595, + 0.59340, 0.59190, 0.58880, 0.58580, 0.58270, 0.57980, 0.57680, 0.57390, 0.571, 0.56820, 0.56540, 0.56260, 0.55990, 0.55710, 0.55440, + 0.55180, 0.54910, 0.54650, 0.54390, 0.54140, 0.53880, 0.53630, 0.53380, 0.53140, 0.52890, 0.52650, 0.52410, 0.51820, 0.51250, 0.50690, + 0.50140, 0.496, 0.49080, 0.48570, 0.48060, 0.47570, 0.47090, 0.46160, 0.45260, 0.444, 0.43570, 0.42780, 0.42010, 0.41270, 0.40550, + 0.39860, 0.392, 0.38550, 0.37930, 0.37330, 0.36740, 3.542e-05, 0.32660, 0.3054}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.66060, 0.65870, 0.65680, 0.65490, 0.653, 0.65120, 0.64930, 0.64750, 0.64570, 0.64390, 0.64210, + 0.64030, 0.63850, 0.63680, 0.635, 0.63330, 0.63160, 0.62990, 0.62820, 0.62650, 0.62480, 0.62310, 0.62150, 0.61980, 0.61820, 0.61650, + 0.61490, 0.61330, 0.61010, 0.607, 0.60380, 0.60070, 0.59770, 0.59470, 0.59170, 0.58870, 0.58580, 0.58290, 0.58010, 0.57720, 0.57440, + 0.57170, 0.56890, 0.56620, 0.56350, 0.56090, 0.55820, 0.55560, 0.55310, 0.55050, 0.548, 0.54550, 0.543, 0.53690, 0.53090, 0.52510, + 0.51940, 0.51390, 0.50840, 0.50310, 0.49790, 0.49280, 0.48780, 0.47820, 0.46890, 0.46, 0.45140, 0.44310, 0.43510, 0.42750, 0.42010, + 0.41290, 0.406, 0.39930, 0.39290, 0.38660, 0.38060, 3.542e-05, 0.33830, 0.3163}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.68250, 0.68050, 0.67860, 0.67660, 0.67470, 0.67280, 0.67090, 0.669, 0.66710, 0.66530, + 0.66340, 0.66160, 0.65980, 0.658, 0.65620, 0.65440, 0.65260, 0.65080, 0.64910, 0.64730, 0.64560, 0.64390, 0.64210, 0.64040, 0.63870, + 0.63710, 0.63540, 0.63210, 0.62880, 0.62550, 0.62230, 0.61920, 0.616, 0.61290, 0.60990, 0.60690, 0.60390, 0.60090, 0.598, 0.59510, + 0.59220, 0.58930, 0.58650, 0.58370, 0.581, 0.57830, 0.57560, 0.57290, 0.57020, 0.56760, 0.565, 0.56240, 0.55610, 0.54990, 0.54390, + 0.538, 0.53230, 0.52660, 0.52110, 0.51570, 0.51040, 0.50530, 0.49520, 0.48560, 0.47640, 0.46750, 0.45890, 0.45070, 0.44270, 0.435, + 0.42760, 0.42050, 0.41360, 0.40690, 0.40040, 0.39410, 3.542e-05, 0.35030, 0.3276}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.705, 0.703, 0.701, 0.699, 0.697, 0.695, 0.69310, 0.69110, 0.68920, + 0.68730, 0.68530, 0.68350, 0.68160, 0.67970, 0.67780, 0.676, 0.67420, 0.67230, 0.67050, 0.66870, 0.66690, 0.66510, 0.66340, 0.66160, + 0.65990, 0.65810, 0.65470, 0.65130, 0.64790, 0.64460, 0.64130, 0.63810, 0.63480, 0.63170, 0.62850, 0.62540, 0.62230, 0.61930, 0.61630, + 0.61330, 0.61040, 0.60740, 0.60460, 0.60170, 0.59890, 0.59610, 0.59330, 0.59050, 0.58780, 0.58510, 0.58250, 0.57590, 0.56950, 0.56330, + 0.55710, 0.55120, 0.54530, 0.53960, 0.534, 0.52860, 0.52320, 0.51280, 0.50280, 0.49330, 0.484, 0.47520, 0.46660, 0.45840, 0.45050, + 0.44280, 0.43540, 0.42820, 0.42130, 0.41460, 0.40810, 3.542e-05, 0.36270, 0.3391}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.72820, 0.72610, 0.724, 0.72190, 0.71990, 0.71780, 0.71580, 0.71380, + 0.71180, 0.70980, 0.70790, 0.70590, 0.704, 0.702, 0.70010, 0.69820, 0.69630, 0.69440, 0.69250, 0.69070, 0.68880, 0.687, 0.68520, + 0.68340, 0.68160, 0.678, 0.67450, 0.671, 0.66750, 0.66410, 0.66070, 0.65740, 0.65410, 0.65080, 0.64760, 0.64440, 0.64130, 0.63810, + 0.63510, 0.632, 0.629, 0.626, 0.623, 0.62010, 0.61720, 0.61430, 0.61150, 0.60860, 0.60580, 0.60310, 0.59630, 0.58960, 0.58320, + 0.57680, 0.57060, 0.56460, 0.55870, 0.55290, 0.54720, 0.54170, 0.53090, 0.52060, 0.51060, 0.50110, 0.49190, 0.48310, 0.47450, 0.46630, + 0.45840, 0.45070, 0.44330, 0.43610, 0.42920, 0.42240, 3.542e-05, 0.37540, 0.3511}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75190, 0.74970, 0.74760, 0.74550, 0.74330, 0.74120, 0.73920, + 0.73710, 0.735, 0.733, 0.73090, 0.72890, 0.72690, 0.72490, 0.723, 0.721, 0.719, 0.71710, 0.71520, 0.71320, 0.71130, 0.70940, + 0.70760, 0.70570, 0.702, 0.69830, 0.69470, 0.69110, 0.68760, 0.68410, 0.68060, 0.67720, 0.67380, 0.67050, 0.66720, 0.66390, 0.66060, + 0.65740, 0.65430, 0.65110, 0.648, 0.645, 0.64190, 0.63890, 0.63590, 0.633, 0.63010, 0.62720, 0.62430, 0.61730, 0.61040, 0.60370, + 0.59710, 0.59070, 0.58440, 0.57830, 0.57230, 0.56640, 0.56070, 0.54950, 0.53880, 0.52850, 0.51870, 0.50910, 0.5, 0.49120, 0.48260, + 0.47440, 0.46650, 0.45880, 0.45140, 0.44420, 0.43720, 3.542e-05, 0.38860, 0.3633}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.77630, 0.774, 0.77180, 0.76960, 0.76740, 0.76530, + 0.76310, 0.761, 0.75890, 0.75670, 0.75470, 0.75260, 0.75050, 0.74840, 0.74640, 0.74440, 0.74240, 0.74040, 0.73840, 0.73640, 0.73440, + 0.73250, 0.73050, 0.72670, 0.72290, 0.71910, 0.71540, 0.71170, 0.70810, 0.70450, 0.701, 0.69750, 0.694, 0.69060, 0.68720, 0.68380, + 0.68050, 0.67720, 0.674, 0.67070, 0.66760, 0.66440, 0.66130, 0.65820, 0.65510, 0.65210, 0.64910, 0.64610, 0.63880, 0.63170, 0.62480, + 0.618, 0.61130, 0.60480, 0.59850, 0.59230, 0.58620, 0.58020, 0.56870, 0.55760, 0.547, 0.53670, 0.52690, 0.51740, 0.50820, 0.49940, + 0.49090, 0.48270, 0.47470, 0.46710, 0.45960, 0.45240, 3.542e-05, 0.40210, 0.3759}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.80130, 0.799, 0.79670, 0.79440, 0.79220, + 0.78990, 0.78770, 0.78550, 0.78330, 0.78110, 0.779, 0.77680, 0.77470, 0.77260, 0.77050, 0.76840, 0.76630, 0.76420, 0.76220, 0.76010, + 0.75810, 0.75610, 0.75210, 0.74820, 0.74430, 0.74040, 0.73660, 0.73280, 0.72910, 0.72540, 0.72180, 0.71820, 0.71470, 0.71110, 0.70770, + 0.70420, 0.70080, 0.69740, 0.69410, 0.69080, 0.68750, 0.68430, 0.68110, 0.67790, 0.67480, 0.67170, 0.66860, 0.661, 0.65370, 0.64650, + 0.63940, 0.63250, 0.62580, 0.61920, 0.61280, 0.60650, 0.60030, 0.58840, 0.57690, 0.56590, 0.55530, 0.54510, 0.53530, 0.52580, 0.51670, + 0.50790, 0.49940, 0.49110, 0.48320, 0.47550, 0.468, 3.542e-05, 0.41590, 0.3889}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.82690, 0.82460, 0.82220, 0.81990, + 0.81750, 0.81520, 0.81290, 0.81070, 0.80840, 0.80620, 0.80390, 0.80170, 0.79950, 0.79730, 0.79520, 0.793, 0.79090, 0.78870, 0.78660, + 0.78450, 0.78240, 0.77830, 0.77420, 0.77010, 0.76610, 0.76220, 0.75830, 0.75440, 0.75060, 0.74690, 0.74310, 0.73940, 0.73580, 0.73220, + 0.72860, 0.72510, 0.72160, 0.71810, 0.71470, 0.71130, 0.708, 0.70470, 0.70140, 0.69810, 0.69490, 0.69170, 0.68390, 0.67630, 0.66880, + 0.66150, 0.65440, 0.64740, 0.64060, 0.63390, 0.62740, 0.621, 0.60870, 0.59680, 0.58540, 0.57440, 0.56390, 0.55370, 0.54390, 0.53450, + 0.52530, 0.51650, 0.508, 0.49980, 0.49180, 0.48410, 3.542e-05, 0.43020, 0.4023}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.85320, 0.85080, 0.84840, + 0.846, 0.84360, 0.84120, 0.83880, 0.83650, 0.83410, 0.83180, 0.82950, 0.82730, 0.825, 0.82270, 0.82050, 0.81830, 0.81610, 0.81390, + 0.81170, 0.80950, 0.80520, 0.801, 0.79680, 0.79260, 0.78850, 0.78450, 0.78050, 0.77650, 0.77260, 0.76880, 0.76490, 0.76120, 0.75740, + 0.75370, 0.75010, 0.74650, 0.74290, 0.73930, 0.73580, 0.73240, 0.72890, 0.72550, 0.72210, 0.71880, 0.71550, 0.70740, 0.69950, 0.69180, + 0.68420, 0.67680, 0.66960, 0.66260, 0.65570, 0.64890, 0.64230, 0.62950, 0.61720, 0.60540, 0.59410, 0.58310, 0.57260, 0.56250, 0.55270, + 0.54330, 0.53420, 0.52540, 0.51690, 0.50860, 0.50060, 3.542e-05, 0.44490, 0.416}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.88020, 0.87770, + 0.87520, 0.87270, 0.87030, 0.86780, 0.86540, 0.86290, 0.86050, 0.85820, 0.85580, 0.85340, 0.85110, 0.84880, 0.84650, 0.84420, 0.84190, + 0.83960, 0.83740, 0.83290, 0.82850, 0.82420, 0.81990, 0.81560, 0.81140, 0.80730, 0.80320, 0.79920, 0.79510, 0.79120, 0.78730, 0.78340, + 0.77960, 0.77580, 0.772, 0.76830, 0.76460, 0.761, 0.75740, 0.75390, 0.75030, 0.74680, 0.74340, 0.74, 0.73160, 0.72340, 0.71540, + 0.70760, 0.69990, 0.69240, 0.68510, 0.678, 0.671, 0.66420, 0.65090, 0.63820, 0.626, 0.61430, 0.603, 0.59210, 0.58160, 0.57150, + 0.56170, 0.55230, 0.54320, 0.53440, 0.52590, 0.51760, 3.542e-05, 0.46, 0.4301}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.90790, + 0.90530, 0.90270, 0.90020, 0.89760, 0.89510, 0.89260, 0.89010, 0.88760, 0.88520, 0.88270, 0.88030, 0.87790, 0.87550, 0.87310, 0.87070, + 0.86840, 0.86610, 0.86140, 0.85690, 0.85240, 0.84790, 0.84350, 0.83920, 0.83490, 0.83060, 0.82640, 0.82230, 0.81820, 0.81410, 0.81010, + 0.80610, 0.80220, 0.79830, 0.79450, 0.79070, 0.78690, 0.78320, 0.77950, 0.77590, 0.77220, 0.76870, 0.76510, 0.75640, 0.74790, 0.73970, + 0.73160, 0.72370, 0.71590, 0.70840, 0.701, 0.69380, 0.68670, 0.673, 0.65980, 0.64720, 0.635, 0.62340, 0.61210, 0.60130, 0.59080, + 0.58070, 0.571, 0.56150, 0.55240, 0.54360, 0.53510, 3.542e-05, 0.47550, 0.4446}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.93630, 0.93360, 0.931, 0.92830, 0.92570, 0.92310, 0.92050, 0.91790, 0.91540, 0.91280, 0.91030, 0.90780, 0.90530, 0.90290, 0.90040, + 0.898, 0.89560, 0.89080, 0.886, 0.88140, 0.87680, 0.87220, 0.86770, 0.86320, 0.85880, 0.85450, 0.85020, 0.84590, 0.84170, 0.83760, + 0.83340, 0.82940, 0.82540, 0.82140, 0.81740, 0.81350, 0.80970, 0.80590, 0.80210, 0.79840, 0.79460, 0.791, 0.782, 0.77320, 0.76460, + 0.75620, 0.74810, 0.74010, 0.73220, 0.72460, 0.71710, 0.70980, 0.69560, 0.682, 0.66890, 0.65640, 0.64430, 0.63270, 0.62150, 0.61060, + 0.60020, 0.59010, 0.58040, 0.571, 0.56190, 0.553, 3.542e-05, 0.49140, 0.4594}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.96540, 0.96260, 0.95990, 0.95720, 0.95450, 0.95180, 0.94910, 0.94650, 0.94380, 0.94120, 0.93860, 0.93610, 0.93350, 0.93090, + 0.92840, 0.92590, 0.92090, 0.916, 0.91120, 0.90640, 0.90170, 0.897, 0.89240, 0.88780, 0.88330, 0.87890, 0.87450, 0.87010, 0.86580, + 0.86150, 0.85730, 0.85320, 0.849, 0.845, 0.84090, 0.83690, 0.833, 0.82910, 0.82520, 0.82140, 0.81760, 0.80830, 0.79920, 0.79030, + 0.78160, 0.77310, 0.76490, 0.75680, 0.74890, 0.74110, 0.73360, 0.71890, 0.70480, 0.69130, 0.67830, 0.66580, 0.65380, 0.64220, 0.631, + 0.62020, 0.60980, 0.59970, 0.59, 0.58060, 0.57150, 3.542e-05, 0.50780, 0.4747}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.99520, 0.99240, 0.98950, 0.98670, 0.984, 0.98120, 0.97840, 0.97570, 0.973, 0.97030, 0.96760, 0.965, 0.96230, + 0.95970, 0.95710, 0.952, 0.94690, 0.94190, 0.93690, 0.932, 0.92720, 0.92240, 0.91770, 0.913, 0.90840, 0.90380, 0.89930, 0.89480, + 0.89040, 0.88610, 0.88170, 0.87750, 0.87320, 0.86910, 0.86490, 0.86080, 0.85680, 0.85280, 0.84880, 0.84490, 0.83520, 0.82580, 0.81670, + 0.80770, 0.79890, 0.79040, 0.782, 0.77380, 0.76580, 0.758, 0.74280, 0.72830, 0.71430, 0.70090, 0.68790, 0.67550, 0.66350, 0.652, + 0.64080, 0.63, 0.61960, 0.60960, 0.59980, 0.59040, 3.542e-05, 0.52460, 0.4905}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 1.026, 1.023, 1.02, 1.017, 1.014, 1.011, 1.008, 1.006, 1.003, 1.0, 0.99740, 0.99460, + 0.99190, 0.98920, 0.98390, 0.97860, 0.97340, 0.96830, 0.96320, 0.95820, 0.95320, 0.94830, 0.94350, 0.93870, 0.934, 0.92930, 0.92470, + 0.92010, 0.91560, 0.91110, 0.90670, 0.90230, 0.898, 0.89370, 0.88950, 0.88530, 0.88110, 0.877, 0.873, 0.863, 0.85330, 0.84380, + 0.83450, 0.82540, 0.81660, 0.80790, 0.79940, 0.79120, 0.78310, 0.76740, 0.75230, 0.73790, 0.724, 0.71060, 0.69780, 0.68540, 0.67350, + 0.66190, 0.65080, 0.64010, 0.62970, 0.61960, 0.60990, 3.542e-05, 0.54180, 0.5066}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 1.057, 1.054, 1.051, 1.048, 1.045, 1.042, 1.039, 1.036, 1.034, 1.031, 1.028, + 1.025, 1.022, 1.017, 1.011, 1.006, 1.0, 0.99520, 0.99, 0.98490, 0.97980, 0.97480, 0.96990, 0.965, 0.96010, 0.95530, + 0.95060, 0.94590, 0.94130, 0.93670, 0.93220, 0.92770, 0.92330, 0.91890, 0.91460, 0.91030, 0.906, 0.90180, 0.89150, 0.88140, 0.87160, + 0.862, 0.85260, 0.84350, 0.83450, 0.82580, 0.81720, 0.80880, 0.79260, 0.77710, 0.76210, 0.74780, 0.734, 0.72070, 0.70790, 0.69550, + 0.68360, 0.67210, 0.661, 0.65030, 0.63990, 0.62980, 3.542e-05, 0.55960, 0.5232}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 1.089, 1.086, 1.083, 1.08, 1.077, 1.074, 1.071, 1.068, 1.065, 1.062, + 1.059, 1.056, 1.05, 1.045, 1.039, 1.034, 1.028, 1.023, 1.017, 1.012, 1.007, 1.002, 0.99680, 0.99180, 0.98680, + 0.982, 0.97710, 0.97230, 0.96760, 0.96290, 0.95830, 0.95370, 0.94910, 0.94470, 0.94020, 0.93580, 0.93150, 0.92080, 0.91040, 0.90020, + 0.89030, 0.88060, 0.87110, 0.86190, 0.85280, 0.844, 0.83530, 0.81850, 0.80250, 0.787, 0.77220, 0.75790, 0.74420, 0.731, 0.71820, + 0.70590, 0.694, 0.68260, 0.67150, 0.66070, 0.65030, 3.542e-05, 0.57780, 0.5402}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.122, 1.119, 1.116, 1.113, 1.109, 1.106, 1.103, 1.1, 1.097, + 1.094, 1.091, 1.085, 1.079, 1.073, 1.068, 1.062, 1.056, 1.051, 1.045, 1.04, 1.035, 1.03, 1.024, 1.019, + 1.014, 1.009, 1.004, 0.99930, 0.99440, 0.98960, 0.98490, 0.98020, 0.97560, 0.971, 0.96640, 0.96190, 0.95090, 0.94010, 0.92960, + 0.91930, 0.90930, 0.89950, 0.88990, 0.88060, 0.87140, 0.86250, 0.84510, 0.82850, 0.81260, 0.79730, 0.78250, 0.76830, 0.75470, 0.74150, + 0.72880, 0.71650, 0.70470, 0.69320, 0.68210, 0.67140, 3.542e-05, 0.59640, 0.5576}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.156, 1.152, 1.149, 1.146, 1.143, 1.139, 1.136, 1.133, + 1.13, 1.127, 1.121, 1.115, 1.109, 1.103, 1.097, 1.091, 1.085, 1.08, 1.074, 1.069, 1.063, 1.058, 1.052, + 1.047, 1.042, 1.037, 1.032, 1.027, 1.022, 1.017, 1.012, 1.007, 1.003, 0.99790, 0.99320, 0.98180, 0.97060, 0.95970, + 0.94910, 0.93880, 0.92860, 0.91880, 0.90910, 0.89960, 0.89040, 0.87250, 0.85530, 0.83880, 0.823, 0.80780, 0.79310, 0.779, 0.76540, + 0.75230, 0.73960, 0.72740, 0.71550, 0.70410, 0.693, 3.542e-05, 0.61560, 0.5755}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.19, 1.187, 1.183, 1.18, 1.177, 1.173, 1.17, + 1.167, 1.164, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.121, 1.115, 1.109, 1.103, 1.098, 1.092, 1.087, + 1.081, 1.076, 1.071, 1.065, 1.06, 1.055, 1.05, 1.045, 1.04, 1.035, 1.03, 1.025, 1.013, 1.002, 0.99070, + 0.97970, 0.969, 0.95860, 0.94840, 0.93840, 0.92860, 0.919, 0.90050, 0.88280, 0.86580, 0.84940, 0.83370, 0.81860, 0.804, 0.78990, + 0.77640, 0.76330, 0.75070, 0.73840, 0.72660, 0.71520, 3.542e-05, 0.63530, 0.5939}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.226, 1.222, 1.219, 1.215, 1.212, 1.208, + 1.205, 1.202, 1.195, 1.188, 1.182, 1.176, 1.169, 1.163, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.122, + 1.116, 1.111, 1.105, 1.1, 1.094, 1.089, 1.084, 1.079, 1.073, 1.068, 1.063, 1.058, 1.046, 1.034, 1.023, + 1.011, 1.0, 0.98930, 0.97870, 0.96840, 0.95830, 0.94840, 0.92930, 0.911, 0.89340, 0.87650, 0.86030, 0.84470, 0.82960, 0.81510, + 0.80110, 0.78760, 0.77460, 0.76190, 0.74970, 0.73790, 3.542e-05, 0.65550, 0.6128}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.262, 1.258, 1.254, 1.251, 1.247, + 1.244, 1.24, 1.234, 1.227, 1.22, 1.213, 1.207, 1.201, 1.194, 1.188, 1.182, 1.176, 1.17, 1.164, 1.158, + 1.152, 1.146, 1.141, 1.135, 1.129, 1.124, 1.118, 1.113, 1.108, 1.102, 1.097, 1.092, 1.08, 1.067, 1.055, + 1.043, 1.032, 1.021, 1.01, 0.99920, 0.98880, 0.97860, 0.95890, 0.93990, 0.92180, 0.90440, 0.88760, 0.87150, 0.85590, 0.84090, + 0.82650, 0.81260, 0.79910, 0.78610, 0.77350, 0.76130, 3.542e-05, 0.67620, 0.6321}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.299, 1.295, 1.291, 1.288, + 1.284, 1.28, 1.273, 1.266, 1.259, 1.252, 1.246, 1.239, 1.232, 1.226, 1.22, 1.213, 1.207, 1.201, 1.195, + 1.189, 1.183, 1.177, 1.171, 1.165, 1.16, 1.154, 1.149, 1.143, 1.138, 1.132, 1.127, 1.114, 1.101, 1.089, + 1.077, 1.065, 1.053, 1.042, 1.031, 1.02, 1.01, 0.98920, 0.96960, 0.95090, 0.93290, 0.91560, 0.89890, 0.88290, 0.86740, + 0.85250, 0.83810, 0.82420, 0.81080, 0.79780, 0.78520, 3.542e-05, 0.69740, 0.652}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.337, 1.333, 1.329, + 1.325, 1.321, 1.314, 1.307, 1.3, 1.292, 1.285, 1.279, 1.272, 1.265, 1.258, 1.252, 1.245, 1.239, 1.233, + 1.227, 1.22, 1.214, 1.208, 1.202, 1.196, 1.191, 1.185, 1.179, 1.174, 1.168, 1.163, 1.149, 1.136, 1.123, + 1.111, 1.098, 1.086, 1.075, 1.063, 1.052, 1.041, 1.02, 1.0, 0.98080, 0.96220, 0.94430, 0.92710, 0.91060, 0.89460, + 0.87920, 0.86440, 0.85, 0.83620, 0.82280, 0.80980, 3.542e-05, 0.7192, 0.6723}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.375, 1.371, + 1.367, 1.364, 1.356, 1.348, 1.341, 1.334, 1.326, 1.319, 1.312, 1.305, 1.298, 1.292, 1.285, 1.278, 1.272, + 1.265, 1.259, 1.253, 1.246, 1.24, 1.234, 1.228, 1.222, 1.216, 1.211, 1.205, 1.199, 1.185, 1.172, 1.158, + 1.145, 1.133, 1.12, 1.108, 1.097, 1.085, 1.074, 1.052, 1.031, 1.011, 0.99220, 0.97380, 0.956, 0.939, 0.92250, + 0.90660, 0.89130, 0.87650, 0.86220, 0.84840, 0.835, 3.542e-05, 0.7416, 0.6932}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.415, + 1.411, 1.407, 1.399, 1.391, 1.383, 1.376, 1.368, 1.361, 1.354, 1.346, 1.339, 1.332, 1.325, 1.319, 1.312, + 1.305, 1.299, 1.292, 1.286, 1.279, 1.273, 1.267, 1.261, 1.255, 1.249, 1.243, 1.237, 1.222, 1.208, 1.195, + 1.181, 1.168, 1.155, 1.143, 1.131, 1.119, 1.107, 1.085, 1.063, 1.043, 1.023, 1.004, 0.98570, 0.96810, 0.95110, + 0.93470, 0.91890, 0.90360, 0.88890, 0.87460, 0.86080, 3.542e-05, 0.7645, 0.7146}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 1.455, 1.451, 1.443, 1.435, 1.427, 1.419, 1.411, 1.404, 1.396, 1.389, 1.381, 1.374, 1.367, 1.36, 1.353, + 1.346, 1.339, 1.332, 1.326, 1.319, 1.313, 1.306, 1.3, 1.294, 1.287, 1.281, 1.275, 1.26, 1.246, 1.232, + 1.218, 1.204, 1.191, 1.178, 1.166, 1.154, 1.142, 1.118, 1.096, 1.075, 1.055, 1.035, 1.016, 0.99790, 0.98040, + 0.96350, 0.94720, 0.93140, 0.91620, 0.90150, 0.88730, 3.542e-05, 0.7879, 0.7365}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.497, 1.488, 1.48, 1.472, 1.464, 1.456, 1.448, + 1.44, 1.432, 1.425, 1.417, 1.41, 1.402, 1.395, 1.388, 1.381, 1.374, 1.367, 1.36, 1.354, 1.347, 1.34, 1.334, 1.327, + 1.321, 1.315, 1.299, 1.284, 1.27, 1.255, 1.242, 1.228, 1.215, 1.202, 1.189, 1.177, 1.153, 1.13, 1.108, 1.087, 1.067, + 1.047, 1.028, 1.01, 0.993, 0.97620, 0.95990, 0.94420, 0.92910, 0.91440, 3.542e-05, 0.812, 0.759}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.583, 1.574, 1.565, 1.556, 1.548, 1.539, + 1.531, 1.522, 1.514, 1.506, 1.498, 1.49, 1.483, 1.475, 1.468, 1.46, 1.453, 1.445, 1.438, 1.431, 1.424, 1.417, 1.41, + 1.404, 1.397, 1.38, 1.364, 1.349, 1.334, 1.319, 1.304, 1.29, 1.276, 1.263, 1.25, 1.224, 1.2, 1.177, 1.154, 1.133, + 1.112, 1.092, 1.073, 1.054, 1.036, 1.019, 1.002, 0.98630, 0.97070, 3.542e-05, 0.8619, 0.8056}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.673, 1.663, 1.654, 1.644, 1.635, + 1.626, 1.617, 1.609, 1.6, 1.592, 1.583, 1.575, 1.567, 1.559, 1.551, 1.543, 1.535, 1.527, 1.52, 1.512, 1.505, 1.498, + 1.49, 1.483, 1.466, 1.449, 1.432, 1.416, 1.4, 1.385, 1.37, 1.355, 1.341, 1.327, 1.299, 1.273, 1.249, 1.225, 1.202, + 1.18, 1.159, 1.138, 1.119, 1.1, 1.081, 1.063, 1.046, 1.03, 3.542e-05, 0.9143, 0.8546}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.766, 1.756, 1.746, 1.737, + 1.727, 1.717, 1.708, 1.699, 1.69, 1.681, 1.672, 1.663, 1.655, 1.646, 1.638, 1.629, 1.621, 1.613, 1.605, 1.597, 1.589, + 1.582, 1.574, 1.555, 1.537, 1.519, 1.502, 1.485, 1.469, 1.453, 1.437, 1.422, 1.407, 1.378, 1.351, 1.324, 1.299, 1.274, + 1.251, 1.229, 1.207, 1.186, 1.166, 1.146, 1.128, 1.109, 1.092, 3.542e-05, 0.9692, 0.9059}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.864, 1.854, 1.843, + 1.833, 1.823, 1.813, 1.803, 1.793, 1.784, 1.774, 1.765, 1.755, 1.746, 1.737, 1.729, 1.72, 1.711, 1.703, 1.694, 1.686, + 1.678, 1.669, 1.649, 1.63, 1.611, 1.593, 1.575, 1.557, 1.54, 1.524, 1.507, 1.492, 1.461, 1.432, 1.403, 1.377, 1.351, + 1.326, 1.302, 1.279, 1.257, 1.235, 1.215, 1.195, 1.175, 1.157, 3.542e-05, 1.027, 0.9597}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.967, 1.955, 1.944, 1.933, 1.923, 1.912, 1.902, 1.891, 1.881, 1.871, + 1.861, 1.852, 1.842, 1.833, 1.823, 1.814, 1.805, 1.796, 1.787, 1.778, 1.77, 1.748, 1.728, 1.707, 1.688, 1.669, 1.65, 1.632, 1.614, + 1.597, 1.58, 1.548, 1.516, 1.487, 1.458, 1.431, 1.404, 1.379, 1.354, 1.331, 1.308, 1.286, 1.265, 1.245, 1.225, 3.542e-05, 1.087, 1.016}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.074, 2.062, 2.05, 2.038, 2.027, 2.016, 2.005, 1.994, 1.983, + 1.973, 1.962, 1.952, 1.942, 1.932, 1.922, 1.912, 1.903, 1.893, 1.884, 1.875, 1.852, 1.83, 1.809, 1.788, 1.767, 1.748, 1.728, 1.709, + 1.691, 1.673, 1.639, 1.605, 1.574, 1.543, 1.514, 1.486, 1.459, 1.434, 1.409, 1.384, 1.361, 1.339, 1.317, 1.296, 3.542e-05, 1.15, 1.075}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.185, 2.172, 2.16, 2.148, 2.136, 2.124, 2.112, 2.101, + 2.09, 2.079, 2.068, 2.057, 2.046, 2.036, 2.025, 2.015, 2.005, 1.995, 1.985, 1.961, 1.937, 1.915, 1.892, 1.871, 1.85, 1.829, 1.809, + 1.79, 1.771, 1.734, 1.699, 1.665, 1.633, 1.602, 1.572, 1.544, 1.516, 1.49, 1.464, 1.44, 1.416, 1.393, 1.371, 3.542e-05, 1.216, 1.137}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.301, 2.288, 2.275, 2.262, 2.249, 2.237, 2.225, + 2.213, 2.201, 2.189, 2.177, 2.166, 2.155, 2.144, 2.133, 2.122, 2.111, 2.101, 2.075, 2.05, 2.026, 2.002, 1.979, 1.957, 1.935, 1.914, + 1.893, 1.873, 1.834, 1.796, 1.761, 1.727, 1.694, 1.662, 1.632, 1.603, 1.575, 1.548, 1.522, 1.497, 1.473, 1.449, 3.542e-05, 1.286, 1.201}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.422, 2.408, 2.394, 2.381, 2.367, 2.354, + 2.341, 2.329, 2.316, 2.304, 2.292, 2.28, 2.268, 2.256, 2.245, 2.233, 2.222, 2.195, 2.168, 2.142, 2.117, 2.093, 2.069, 2.046, 2.023, + 2.001, 1.98, 1.938, 1.899, 1.861, 1.825, 1.79, 1.757, 1.725, 1.694, 1.664, 1.635, 1.608, 1.581, 1.556, 1.531, 3.542e-05, 1.358, 1.269}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.548, 2.533, 2.519, 2.505, 2.491, + 2.477, 2.463, 2.45, 2.437, 2.424, 2.411, 2.398, 2.386, 2.373, 2.361, 2.349, 2.32, 2.292, 2.264, 2.238, 2.212, 2.186, 2.162, 2.138, + 2.114, 2.091, 2.048, 2.006, 1.965, 1.927, 1.89, 1.855, 1.821, 1.789, 1.757, 1.727, 1.698, 1.67, 1.642, 1.616, 3.542e-05, 1.433, 1.339}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.679, 2.664, 2.648, 2.633, + 2.619, 2.604, 2.59, 2.576, 2.562, 2.548, 2.535, 2.522, 2.508, 2.495, 2.483, 2.452, 2.421, 2.392, 2.364, 2.336, 2.309, 2.283, 2.258, + 2.233, 2.209, 2.162, 2.117, 2.075, 2.034, 1.995, 1.958, 1.922, 1.888, 1.854, 1.822, 1.792, 1.762, 1.733, 1.705, 3.542e-05, 1.512, 1.413}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.816, 2.8, 2.783, + 2.768, 2.752, 2.737, 2.722, 2.707, 2.692, 2.678, 2.664, 2.65, 2.636, 2.622, 2.589, 2.557, 2.526, 2.496, 2.466, 2.438, 2.41, 2.383, + 2.357, 2.331, 2.282, 2.234, 2.189, 2.146, 2.105, 2.066, 2.028, 1.991, 1.956, 1.922, 1.89, 1.858, 1.828, 1.799, 3.542e-05, 1.595, 1.490}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.958, 2.941, + 2.924, 2.907, 2.891, 2.875, 2.859, 2.843, 2.828, 2.813, 2.798, 2.783, 2.769, 2.733, 2.699, 2.666, 2.634, 2.603, 2.572, 2.543, 2.514, + 2.486, 2.459, 2.407, 2.357, 2.309, 2.263, 2.22, 2.178, 2.138, 2.099, 2.062, 2.026, 1.992, 1.959, 1.927, 1.896, 3.542e-05, 1.681, 1.570}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.106, + 3.088, 3.07, 3.052, 3.035, 3.018, 3.001, 2.985, 2.969, 2.953, 2.937, 2.922, 2.884, 2.848, 2.812, 2.778, 2.745, 2.713, 2.682, 2.651, + 2.622, 2.593, 2.537, 2.484, 2.434, 2.386, 2.34, 2.295, 2.253, 2.212, 2.173, 2.135, 2.099, 2.064, 2.03, 1.997, 3.542e-05, 1.77, 1.654}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 3.26, 3.24, 3.222, 3.203, 3.185, 3.167, 3.15, 3.132, 3.115, 3.099, 3.082, 3.042, 3.003, 2.966, 2.929, 2.894, 2.86, 2.827, 2.794, + 2.763, 2.732, 2.674, 2.618, 2.564, 2.513, 2.465, 2.418, 2.373, 2.33, 2.289, 2.249, 2.21, 2.173, 2.138, 2.103, 3.542e-05, 1.864, 1.741}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 3.419, 3.399, 3.379, 3.36, 3.341, 3.322, 3.304, 3.286, 3.268, 3.25, 3.207, 3.166, 3.126, 3.087, 3.05, 3.014, 2.978, 2.944, + 2.911, 2.878, 2.816, 2.757, 2.7, 2.646, 2.595, 2.546, 2.498, 2.453, 2.409, 2.367, 2.326, 2.287, 2.25, 2.213, 3.542e-05, 1.961, 1.832}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 3.585, 3.564, 3.543, 3.523, 3.503, 3.483, 3.464, 3.445, 3.426, 3.38, 3.336, 3.294, 3.253, 3.213, 3.174, 3.137, 3.1, + 3.065, 3.031, 2.965, 2.902, 2.842, 2.785, 2.731, 2.679, 2.629, 2.581, 2.535, 2.49, 2.448, 2.406, 2.367, 2.328, 3.542e-05, 2.063, 1.926}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 3.758, 3.735, 3.713, 3.692, 3.671, 3.65, 3.63, 3.61, 3.561, 3.514, 3.469, 3.425, 3.383, 3.342, 3.302, 3.264, + 3.226, 3.19, 3.12, 3.054, 2.99, 2.93, 2.873, 2.818, 2.765, 2.714, 2.665, 2.619, 2.574, 2.53, 2.488, 2.448, 3.542e-05, 2.168, 2.025}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 3.937, 3.913, 3.89, 3.867, 3.845, 3.823, 3.802, 3.75, 3.7, 3.652, 3.605, 3.561, 3.517, 3.475, 3.434, + 3.394, 3.356, 3.282, 3.212, 3.145, 3.081, 3.02, 2.962, 2.907, 2.853, 2.802, 2.752, 2.705, 2.659, 2.615, 2.573, 3.542e-05, 2.278, 2.127}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 4.122, 4.097, 4.073, 4.049, 4.026, 4.003, 3.948, 3.895, 3.843, 3.794, 3.746, 3.7, 3.655, 3.612, + 3.57, 3.529, 3.451, 3.376, 3.306, 3.238, 3.174, 3.113, 3.054, 2.998, 2.944, 2.892, 2.842, 2.794, 2.747, 2.702, 3.542e-05, 2.392, 2.234}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.315, 4.289, 4.263, 4.238, 4.214, 4.155, 4.098, 4.043, 3.991, 3.94, 3.891, 3.843, 3.797, + 3.753, 3.709, 3.627, 3.548, 3.473, 3.402, 3.335, 3.27, 3.208, 3.148, 3.091, 3.037, 2.984, 2.933, 2.884, 2.837, 3.542e-05, 2.511, 2.344}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.515, 4.487, 4.46, 4.434, 4.371, 4.31, 4.252, 4.196, 4.142, 4.09, 4.04, 3.991, + 3.944, 3.898, 3.81, 3.727, 3.648, 3.573, 3.501, 3.433, 3.368, 3.305, 3.245, 3.187, 3.132, 3.079, 3.027, 2.977, 3.542e-05, 2.635, 2.459}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.722, 4.693, 4.665, 4.597, 4.532, 4.47, 4.411, 4.353, 4.298, 4.244, 4.193, + 4.143, 4.094, 4.001, 3.913, 3.83, 3.751, 3.675, 3.603, 3.534, 3.468, 3.405, 3.344, 3.286, 3.23, 3.176, 3.123, 3.542e-05, 2.763, 2.579}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.936, 4.906, 4.833, 4.764, 4.698, 4.635, 4.574, 4.515, 4.458, 4.403, + 4.35, 4.298, 4.2, 4.107, 4.019, 3.935, 3.856, 3.78, 3.707, 3.638, 3.571, 3.507, 3.446, 3.387, 3.33, 3.275, 3.542e-05, 2.896, 2.703}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.159, 5.081, 5.007, 4.936, 4.868, 4.803, 4.741, 4.681, 4.622, + 4.566, 4.512, 4.407, 4.309, 4.216, 4.128, 4.044, 3.964, 3.887, 3.814, 3.744, 3.677, 3.612, 3.55, 3.49, 3.432, 3.542e-05, 3.035, 2.832}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.75, 5.662, 5.579, 5.499, 5.423, 5.35, 5.28, 5.212, + 5.147, 5.084, 4.964, 4.851, 4.744, 4.643, 4.547, 4.456, 4.369, 4.286, 4.206, 4.13, 4.056, 3.986, 3.918, 3.853, 3.542e-05, 3.404, 3.176}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.395, 6.296, 6.202, 6.112, 6.027, 5.945, 5.866, + 5.79, 5.717, 5.579, 5.449, 5.327, 5.211, 5.102, 4.998, 4.898, 4.804, 4.714, 4.627, 4.544, 4.464, 4.388, 4.314, 3.542e-05, 3.808, 3.552}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.098, 6.985, 6.879, 6.779, 6.683, 6.591, + 6.503, 6.418, 6.258, 6.108, 5.968, 5.836, 5.711, 5.593, 5.48, 5.373, 5.27, 5.172, 5.078, 4.988, 4.902, 4.819, 3.542e-05, 4.25, 3.962}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.861, 7.734, 7.615, 7.502, 7.395, + 7.292, 7.193, 7.008, 6.835, 6.674, 6.523, 6.38, 6.245, 6.118, 5.996, 5.88, 5.769, 5.663, 5.561, 5.464, 5.37, 3.542e-05, 4.732, 4.410}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.69, 8.547, 8.413, 8.286, + 8.166, 8.051, 7.835, 7.636, 7.451, 7.278, 7.115, 6.961, 6.816, 6.678, 6.547, 6.421, 6.302, 6.187, 6.078, 5.972, 3.542e-05, 5.257, 4.897}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 9.588, 9.428, 9.277, + 9.135, 9.0, 8.749, 8.519, 8.305, 8.106, 7.92, 7.745, 7.58, 7.423, 7.275, 7.133, 6.998, 6.87, 6.746, 6.628, 3.542e-05, 5.827, 5.425}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.56, 10.38, + 10.21, 10.05, 9.759, 9.491, 9.244, 9.016, 8.803, 8.603, 8.415, 8.238, 8.069, 7.91, 7.758, 7.613, 7.474, 7.341, 3.542e-05, 6.445, 5.998}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 11.62, + 11.41, 11.22, 10.88, 10.56, 10.28, 10.01, 9.769, 9.541, 9.328, 9.126, 8.936, 8.756, 8.584, 8.421, 8.265, 8.116, 3.542e-05, 7.115, 6.618}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 12.75, 12.53, 12.11, 11.75, 11.41, 11.11, 10.83, 10.57, 10.32, 10.1, 9.88, 9.676, 9.483, 9.299, 9.124, 8.957, 3.542e-05, 7.84, 7.288}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 13.99, 13.49, 13.05, 12.67, 12.31, 11.99, 11.69, 11.41, 11.15, 10.91, 10.68, 10.46, 10.25, 10.06, 9.869, 3.542e-05, 8.623, 8.011}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 16.75, 16.12, 15.58, 15.1, 14.66, 14.26, 13.9, 13.56, 13.25, 12.95, 12.67, 12.41, 12.16, 11.93, 3.542e-05, 10.38, 9.628}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 19.97, 19.17, 18.49, 17.89, 17.36, 16.87, 16.43, 16.02, 15.64, 15.28, 14.95, 14.63, 14.34, 3.542e-05, 12.42, 11.5}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 23.71, 22.7, 21.85, 21.1, 20.45, 19.85, 19.31, 18.81, 18.35, 17.93, 17.53, 17.15, 3.542e-05, 14.77, 13.65}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 28.07, 26.78, 25.71, 24.79, 23.97, 23.25, 22.59, 21.99, 21.44, 20.93, 20.45, 3.542e-05, 17.48, 16.12}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 33.16, 31.5, 30.15, 29.0, 28.0, 27.11, 26.31, 25.59, 24.92, 24.31, 3.542e-05, 20.6, 18.94}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 39.13, 36.97, 35.25, 33.82, 32.58, 31.5, 30.53, 29.65, 28.86, 3.542e-05, 24.19, 22.16}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 46.17, 43.33, 41.13, 39.33, 37.8, 36.47, 35.29, 34.24, 3.542e-05, 28.31, 25.84}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 54.54, 50.75, 47.92, 45.65, 43.75, 42.11, 40.68, 3.542e-05, 33.07, 30.03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 64.64, 59.47, 55.78, 52.9, 50.53, 48.51, 3.542e-05, 38.55, 34.81}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 77.05, 69.8, 64.93, 61.24, 58.27, 3.542e-05, 44.92, 40.28}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 92.76, 82.18, 75.63, 70.87, 3.542e-05, 52.35, 46.54}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 113.6, 97.22, 88.27, 3.542e-05, 61.12, 53.76}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 143.9, 115.8, 3.542e-05, 71.6, 62.15}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 201.8, 3.542e-05, 84.38, 71.99}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 148.4, 115.1}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 201.7, 144.2}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 270.9, 177.8}} + }; +#endif // UNUSED_FLUID_PROPS + } // namespace Fluid } // namespace EnergyPlus diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 3d76c7bbe8f..7e5fd99334a 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -99,11 +99,30 @@ namespace FluidProperties { std::uint64_t constexpr t_sh_cache_mask = (t_sh_cache_size - 1); #endif - struct RefrigerantData + enum class RefrigError + { + Invalid = -1, + SatTemp, + SatPress, + SatTempDensity, + SatSupEnthalpy, + SatSupEnthalpyTemp, + SatSupEnthalpyPress, + SatSupPress, + SatSupPressTemp, + SatSupPressEnthalpy, + SatSupDensity, + SatSupDensityTemp, + SatSupDensityPress, + Num + }; + + struct RefrigProps { // Members std::string Name; // Name of the refrigerant int Num = 0; + bool used = false; int NumPsPoints = 0; // Number of saturation pressure Real64 PsLowTempValue = 0.0; // Low Temperature Value for Ps (>0.0) @@ -163,6 +182,8 @@ namespace FluidProperties { Array2D HshValues; // Enthalpy of superheated gas at HshTemps, HshPress Array2D RhoshValues; // Density of superheated gas at HshTemps, HshPress + std::array errors; + Real64 getQuality(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Enthalpy, // actual enthalpy given as input @@ -214,7 +235,21 @@ namespace FluidProperties { std::string_view CalledFrom); // routine this function was called from (error messages) }; - struct GlycolRawData + enum class GlycolError + { + Invalid = -1, + SpecHeatLow, + SpecHeatHigh, + DensityLow, + DensityHigh, + ConductivityLow, + ConductivityHigh, + ViscosityLow, + ViscosityHigh, + Num + }; + + struct GlycolRawProps { // Members std::string Name; // Name of the glycol @@ -249,11 +284,12 @@ namespace FluidProperties { Array2D ViscValues; // viscosity values }; - struct GlycolData + struct GlycolProps { // Members std::string Name; // Name of the glycol mixture (used by other parts of code) int Num = 0; + bool used = false; std::string GlycolName; // Name of non-water fluid that is part of this mixture // (refers to ethylene glycol, propylene glycol, or user fluid) @@ -297,6 +333,8 @@ namespace FluidProperties { Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscValues; // viscosity values (mPa-s) + std::array errors; + #ifdef EP_cache_GlycolSpecificHeat Real64 getSpecificHeat_raw(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input @@ -320,58 +358,6 @@ namespace FluidProperties { std::string_view CalledFrom); // routine this function was called from (error messages) }; - struct RefrigErrors - { - // Members - std::string Name; - int SatTempErrIndex = 0; // Index for Sat Temperature Error (Recurring errors) - int SatTempErrCount = 0; // Count for Sat Temperature Error (Recurring errors) - int SatPressErrIndex = 0; // Index for Sat Pressure Error (Recurring errors) - int SatPressErrCount = 0; // Count for Sat Pressure Error (Recurring errors) - int SatTempDensityErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatTempDensityErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyPresErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupEnthalpyPresErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureEnthErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupPressureEnthErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityTempErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityTempErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityPresErrIndex = 0; // Index for Sat Temperature (Density) Error (Recurring errors) - int SatSupDensityPresErrCount = 0; // Count for Sat Temperature (Density) Error (Recurring errors) - }; - - struct GlycolErrors - { - // Members - std::string Name; // Which glycol this error structure is for - int SpecHeatLowErrIndex = 0; // Index for Specific Heat Low Error (Recurring errors) - int SpecHeatHighErrIndex = 0; // Index for Specific Heat High Error (Recurring errors) - int SpecHeatLowErrCount = 0; // Count for Specific Heat Low Error (Recurring errors) - int SpecHeatHighErrCount = 0; // Count for Specific Heat High Error (Recurring errors) - int DensityHighErrCount = 0; // Index for Density Low Error (Recurring errors) - int DensityLowErrIndex = 0; // Index for Density High Error (Recurring errors) - int DensityHighErrIndex = 0; // Count for Density Low Error (Recurring errors) - int DensityLowErrCount = 0; // Count for Density High Error (Recurring errors) - int ConductivityLowErrIndex = 0; // Index for Conductivity Low Error (Recurring errors) - int ConductivityHighErrIndex = 0; // Index for Conductivity High Error (Recurring errors) - int ConductivityLowErrCount = 0; // Count for Conductivity Low Error (Recurring errors) - int ConductivityHighErrCount = 0; // Count for Conductivity High Error (Recurring errors) - int ViscosityLowErrIndex = 0; // Index for Viscosity Low Error (Recurring errors) - int ViscosityHighErrIndex = 0; // Index for Viscosity High Error (Recurring errors) - int ViscosityLowErrCount = 0; // Count for Viscosity Low Error (Recurring errors) - int ViscosityHighErrCount = 0; // Count for Viscosity High Error (Recurring errors) - }; - struct cached_tsh { // Members @@ -567,10 +553,10 @@ namespace FluidProperties { } int GetRefrigNum(EnergyPlusData &state, std::string_view name); - RefrigerantData *GetRefrig(EnergyPlusData &state, std::string_view name); + RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view name); int GetGlycolNum(EnergyPlusData &state, std::string_view name); - GlycolData *GetGlycol(EnergyPlusData &state, std::string_view name); + GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view name); std::string GetGlycolNameByIndex(EnergyPlusData &state, int Idx); // carries in substance index @@ -600,26 +586,6 @@ namespace FluidProperties { void ReportOrphanFluids(EnergyPlusData &state); - void ReportFatalGlycolErrors(EnergyPlusData &state, - int NumGlycols, // Number of Glycols in input/data - int GlycolNum, // Glycol Index - bool DataPresent, // data is present for this fluid. - std::string_view GlycolName, // Name being reported - std::string_view RoutineName, // Routine name to show - std::string_view Property, // Property being requested - std::string_view CalledFrom // original called from (external to fluid properties) - ); - - void ReportFatalRefrigerantErrors(EnergyPlusData &state, - int NumRefrigerants, // Number of Refrigerants in input/data - int RefrigerantNum, // Refrigerant Index - bool DataPresent, // data is present for this fluid. - std::string_view RefrigerantName, // Name being reported - std::string_view RoutineName, // Routine name to show - std::string_view Property, // Property being requested - std::string_view CalledFrom // original called from (external to fluid properties) - ); - void GetFluidDensityTemperatureLimits(EnergyPlusData &state, int FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit); void GetFluidSpecificHeatTemperatureLimits(EnergyPlusData &state, int FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit); @@ -664,26 +630,16 @@ struct FluidData : BaseGlobalStruct bool DebugReportGlycols = false; bool DebugReportRefrigerants = false; int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called - int RefrigerantErrorLimitTest = 1; // how many times error is printed with details before recurring called - Array1D_bool RefrigUsed; - Array1D_bool GlycolUsed; + int RefrigErrorLimitTest = 1; // how many times error is printed with details before recurring called - Array1D RefrigData; - Array1D RefrigErrorTracking; - Array1D GlyRawData; - Array1D GlycolData; - Array1D GlycolErrorTracking; + Array1D RefrigData; + Array1D GlyRawData; + Array1D GlycolData; + std::array glycolErrorLimits = {0, 0, 0, 0, 0, 0, 0, 0}; + int SatErrCountGetSupHeatEnthalpyRefrig = 0; int SatErrCountGetSupHeatDensityRefrig = 0; - int HighTempLimitErrGetSpecificHeatGlycol_raw = 0; - int LowTempLimitErrGetSpecificHeatGlycol_raw = 0; - int HighTempLimitErrGetDensityGlycol = 0; - int LowTempLimitErrGetDensityGlycol = 0; - int HighTempLimitErrGetConductivityGlycol = 0; - int LowTempLimitErrGetConductivityGlycol = 0; - int HighTempLimitErrGetViscosityGlycol = 0; - int LowTempLimitErrGetViscosityGlycol = 0; int TempLoRangeErrIndexGetQualityRefrig = 0; int TempHiRangeErrIndexGetQualityRefrig = 0; int TempRangeErrCountGetInterpolatedSatProp = 0; diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh index 0c964296861..b1448855c2b 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh @@ -361,7 +361,7 @@ namespace HVACVariableRefrigerantFlow { Real64 OUEvapHeatRate; // Outdoor Unit Evaporator Heat Extract Rate, excluding piping loss [W] Real64 OUFanPower; // Outdoor unit fan power at real conditions[W] std::string refrigName; // Name of refrigerant, must match name in FluidName (see fluidpropertiesrefdata.idf) - FluidProperties::RefrigerantData *refrig; + FluidProperties::RefrigProps *refrig; Real64 RatedEvapCapacity; // Rated Evaporative Capacity [W] Real64 RatedHeatCapacity; // Rated Heating Capacity [W] Real64 RatedCompPower; // Rated Compressor Power [W] diff --git a/src/EnergyPlus/UtilityRoutines.hh b/src/EnergyPlus/UtilityRoutines.hh index 6017ba557b2..3bfc0caf4f1 100644 --- a/src/EnergyPlus/UtilityRoutines.hh +++ b/src/EnergyPlus/UtilityRoutines.hh @@ -220,6 +220,12 @@ void SummarizeErrors(EnergyPlusData &state); void ShowRecurringErrors(EnergyPlusData &state); +struct ErrorCountIndex +{ + int index = 0; + int count = 0; +}; + struct ErrorObjectHeader { std::string_view routineName; From a242572180f8674f4715360116312d43bff8b636 Mon Sep 17 00:00:00 2001 From: amirroth Date: Sat, 20 Jul 2024 07:00:07 -0400 Subject: [PATCH 108/115] GetInput cleanup --- src/EnergyPlus/Data/EnergyPlusData.cc-e | 831 ---- src/EnergyPlus/Data/EnergyPlusData.hh-e | 586 --- src/EnergyPlus/FluidProperties.cc | 4212 +++++++---------- src/EnergyPlus/FluidProperties.hh | 153 +- src/EnergyPlus/NodeInputManager.cc | 2 +- src/EnergyPlus/OutdoorAirUnit.cc | 2 +- src/EnergyPlus/PoweredInductionUnits.cc | 2 +- src/EnergyPlus/SteamBaseboardRadiator.cc | 2 +- src/EnergyPlus/SteamCoils.cc | 2 +- src/EnergyPlus/VentilatedSlab.cc | 2 +- .../unit/Fixtures/EnergyPlusFixture.cc | 1 - .../unit/HVACVariableRefrigerantFlow.unit.cc | 8 +- tst/EnergyPlus/unit/PlantUtilities.unit.cc | 8 +- tst/EnergyPlus/unit/SetPointManager.unit.cc | 8 +- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 1 - tst/EnergyPlus/unit/WaterCoils.unit.cc | 9 - tst/EnergyPlus/unit/WaterThermalTanks.unit.cc | 2 +- .../unit/WaterToAirHeatPump.unit.cc | 117 +- 18 files changed, 1739 insertions(+), 4209 deletions(-) delete mode 100644 src/EnergyPlus/Data/EnergyPlusData.cc-e delete mode 100644 src/EnergyPlus/Data/EnergyPlusData.hh-e diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc-e b/src/EnergyPlus/Data/EnergyPlusData.cc-e deleted file mode 100644 index 4c015de9731..00000000000 --- a/src/EnergyPlus/Data/EnergyPlusData.cc-e +++ /dev/null @@ -1,831 +0,0 @@ -// EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois, -// The Regents of the University of California, through Lawrence Berkeley National Laboratory -// (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge -// National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other -// contributors. All rights reserved. -// -// NOTICE: This Software was developed under funding from the U.S. Department of Energy and the -// U.S. Government consequently retains certain rights. As such, the U.S. Government has been -// granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, -// worldwide license in the Software to reproduce, distribute copies to the public, prepare -// derivative works, and perform publicly and display publicly, and to permit others to do so. -// -// Redistribution and use in source and binary forms, with or without modification, are permitted -// provided that the following conditions are met: -// -// (1) Redistributions of source code must retain the above copyright notice, this list of -// conditions and the following disclaimer. -// -// (2) Redistributions in binary form must reproduce the above copyright notice, this list of -// conditions and the following disclaimer in the documentation and/or other materials -// provided with the distribution. -// -// (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, -// the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be -// used to endorse or promote products derived from this software without specific prior -// written permission. -// -// (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form -// without changes from the version obtained under this License, or (ii) Licensee makes a -// reference solely to the software portion of its product, Licensee must refer to the -// software as "EnergyPlus version X" software, where "X" is the version number Licensee -// obtained under this License and may not use a different name for the software. Except as -// specifically required in this Section (4), Licensee shall not use in a company name, a -// product name, in advertising, publicity, or other promotional activities any name, trade -// name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly -// similar designation, without the U.S. Department of Energy's prior written consent. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR -// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY -// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. - -#include -#include - -#include - -namespace EnergyPlus { - -EnergyPlusData::EnergyPlusData() -{ - this->dataAirLoop = std::make_unique(); - this->dataAirLoopHVACDOAS = std::make_unique(); - this->dataAirSystemsData = std::make_unique(); - this->afn = std::make_unique(*this); - this->dataBSDFWindow = std::make_unique(); - this->dataBaseSizerFanHeatInputs = std::make_unique(); - this->dataBaseSizerScalableInputs = std::make_unique(); - this->dataBaseboardElectric = std::make_unique(); - this->dataBaseboardRadiator = std::make_unique(); - this->dataBoilerSteam = std::make_unique(); - this->dataBoilers = std::make_unique(); - this->dataBranchAirLoopPlant = std::make_unique(); - this->dataBranchInputManager = std::make_unique(); - this->dataBranchNodeConnections = std::make_unique(); - this->dataCHPElectGen = std::make_unique(); - this->dataCTElectricGenerator = std::make_unique(); - this->dataChilledCeilingPanelSimple = std::make_unique(); - this->dataChillerAbsorber = std::make_unique(); - this->dataChillerElectricEIR = std::make_unique(); - this->dataChillerExhaustAbsorption = std::make_unique(); - this->dataChillerGasAbsorption = std::make_unique(); - this->dataChillerIndirectAbsorption = std::make_unique(); - this->dataChillerReformulatedEIR = std::make_unique(); - this->dataChillerElectricASHRAE205 = std::make_unique(); - this->dataCoilCooingDX = std::make_unique(); - this->dataCondenserLoopTowers = std::make_unique(); - this->dataConstruction = std::make_unique(); - this->dataContaminantBalance = std::make_unique(); - this->dataConvect = std::make_unique(); - this->dataConvergeParams = std::make_unique(); - this->dataCoolTower = std::make_unique(); - this->dataCostEstimateManager = std::make_unique(); - this->dataCrossVentMgr = std::make_unique(); - this->dataCurveManager = std::make_unique(); - this->dataDXCoils = std::make_unique(); - this->dataDXFEarClipping = std::make_unique(); - this->dataDaylightingDevices = std::make_unique(); - this->dataDaylightingDevicesData = std::make_unique(); - this->dataDayltg = std::make_unique(); - this->dataDefineEquipment = std::make_unique(); - this->dataDemandManager = std::make_unique(); - this->dataDesiccantDehumidifiers = std::make_unique(); - this->dataDispVentMgr = std::make_unique(); - this->dataDualDuct = std::make_unique(); - this->dataEIRFuelFiredHeatPump = std::make_unique(); - this->dataEIRPlantLoopHeatPump = std::make_unique(); - this->dataEMSMgr = std::make_unique(); - this->dataEarthTube = std::make_unique(); - this->dataEcoRoofMgr = std::make_unique(); - this->dataEconLifeCycleCost = std::make_unique(); - this->dataEconTariff = std::make_unique(); - this->dataElectBaseboardRad = std::make_unique(); - this->dataElectPwrSvcMgr = std::make_unique(); - this->dataEnvrn = std::make_unique(); - this->dataErrTracking = std::make_unique(); - this->dataEvapCoolers = std::make_unique(); - this->dataEvapFluidCoolers = std::make_unique(); - this->dataExteriorEnergyUse = std::make_unique(); - this->dataExternalInterface = std::make_unique(); - this->dataFanCoilUnits = std::make_unique(); - this->dataFans = std::make_unique(); - this->dataFaultsMgr = std::make_unique(); - this->dataFluidCoolers = std::make_unique(); - this->dataFluidProperties = std::make_unique(); - this->dataFourPipeBeam = std::make_unique(); - this->dataFuelCellElectGen = std::make_unique(); - this->dataFurnaces = std::make_unique(); - this->dataGeneral = std::make_unique(); - this->dataGeneralRoutines = std::make_unique(); - this->dataGenerator = std::make_unique(); - this->dataGeneratorFuelSupply = std::make_unique(); - this->dataGlobal = std::make_unique(); - this->dataGlobalNames = std::make_unique(); - this->dataGrndTempModelMgr = std::make_unique(); - this->dataGroundHeatExchanger = std::make_unique(); - this->dataHPWaterToWaterClg = std::make_unique(); - this->dataHPWaterToWaterHtg = std::make_unique(); - this->dataHPWaterToWaterSimple = std::make_unique(); - this->dataHVACAssistedCC = std::make_unique(); - this->dataHVACControllers = std::make_unique(); - this->dataHVACCooledBeam = std::make_unique(); - this->dataHVACCtrl = std::make_unique(); - this->dataHVACDXHeatPumpSys = std::make_unique(); - this->dataHVACDuct = std::make_unique(); - this->dataHVACGlobal = std::make_unique(); - this->dataHVACInterfaceMgr = std::make_unique(); - this->dataHVACMgr = std::make_unique(); - this->dataHVACMultiSpdHP = std::make_unique(); - this->dataHVACSingleDuctInduc = std::make_unique(); - this->dataHVACSizingSimMgr = std::make_unique(); - this->dataHVACStandAloneERV = std::make_unique(); - this->dataHVACUnitaryBypassVAV = std::make_unique(); - this->dataHVACVarRefFlow = std::make_unique(); - this->dataHWBaseboardRad = std::make_unique(); - this->dataHeatBal = std::make_unique(); - this->dataHeatBalAirMgr = std::make_unique(); - this->dataHeatBalFanSys = std::make_unique(); - this->dataHeatBalFiniteDiffMgr = std::make_unique(); - this->dataHeatBalHAMTMgr = std::make_unique(); - this->dataHeatBalIntHeatGains = std::make_unique(); - this->dataHeatBalIntRadExchg = std::make_unique(); - this->dataHeatBalMgr = std::make_unique(); - this->dataHeatBalSurf = std::make_unique(); - this->dataHeatBalSurfMgr = std::make_unique(); - this->dataHeatRecovery = std::make_unique(); - this->dataHeatingCoils = std::make_unique(); - this->dataHighTempRadSys = std::make_unique(); - this->dataHumidifiers = std::make_unique(); - this->dataHybridModel = std::make_unique(); - this->dataHybridUnitaryAC = std::make_unique(); - this->dataHysteresisPhaseChange = std::make_unique(); - this->dataICEngElectGen = std::make_unique(); - this->dataIndoorGreen = std::make_unique(); - this->dataInputProcessing = std::make_unique(); - this->dataIPShortCut = std::make_unique(); - this->dataIceThermalStorage = std::make_unique(); - this->dataIntegratedHP = std::make_unique(); - this->dataInternalHeatGains = std::make_unique(); - this->dataLoopNodes = std::make_unique(); - this->dataLowTempRadSys = std::make_unique(); - this->dataMaterial = std::make_unique(); - this->dataMatrixDataManager = std::make_unique(); - this->dataMircoturbElectGen = std::make_unique(); - this->dataMixedAir = std::make_unique(); - this->dataMixerComponent = std::make_unique(); - this->dataMoistureBalEMPD = std::make_unique(); - this->dataMstBal = std::make_unique(); - this->dataMstBalEMPD = std::make_unique(); - this->dataMundtSimMgr = std::make_unique(); - this->dataNodeInputMgr = std::make_unique(); - this->dataOutAirNodeMgr = std::make_unique(); - this->dataOutRptPredefined = std::make_unique(); - this->dataOutRptTab = std::make_unique(); - this->dataOutdoorAirUnit = std::make_unique(); - this->dataOutput = std::make_unique(); - this->dataOutputProcessor = std::make_unique(); - this->dataOutputReportTabularAnnual = std::make_unique(); - this->dataOutputReports = std::make_unique(); - this->dataOutsideEnergySrcs = std::make_unique(); - this->dataPackagedThermalStorageCoil = std::make_unique(); - this->dataPhotovoltaic = std::make_unique(); - this->dataPhotovoltaicState = std::make_unique(); - this->dataPhotovoltaicThermalCollector = std::make_unique(); - this->dataPipeHT = std::make_unique(); - this->dataPipes = std::make_unique(); - this->dataPlantCentralGSHP = std::make_unique(); - this->dataPlantChillers = std::make_unique(); - this->dataPlantCompTempSrc = std::make_unique(); - this->dataPlantCondLoopOp = std::make_unique(); - this->dataPlantHXFluidToFluid = std::make_unique(); - this->dataPlantLoadProfile = std::make_unique(); - this->dataPlantMgr = std::make_unique(); - this->dataPlantPipingSysMgr = std::make_unique(); - this->dataPlantPressureSys = std::make_unique(); - this->dataPlantUtilities = std::make_unique(); - this->dataPlantValves = std::make_unique(); - this->dataPlnt = std::make_unique(); - this->dataPluginManager = std::make_unique(); - this->dataPollution = std::make_unique(); - this->dataPondGHE = std::make_unique(); - this->dataPowerInductionUnits = std::make_unique(); - this->dataPsychrometrics = std::make_unique(); - this->dataPsychCache = std::make_unique(); - this->dataPumps = std::make_unique(); - this->dataPurchasedAirMgr = std::make_unique(); - this->dataRefrigCase = std::make_unique(); - this->dataReportFlag = std::make_unique(); - this->dataResultsFramework = std::make_unique(); - this->dataRetAirPathMrg = std::make_unique(); - this->dataExhAirSystemMrg = std::make_unique(); - this->dataExhCtrlSystemMrg = std::make_unique(); - this->dataRoomAir = std::make_unique(); - this->dataRoomAirModelTempPattern = std::make_unique(); - this->dataRoomAirflowNetModel = std::make_unique(); - this->dataRootFinder = std::make_unique(); - this->dataRptCoilSelection = std::make_unique(); - this->dataRuntimeLang = std::make_unique(); - this->dataRuntimeLangProcessor = std::make_unique(); - this->dataSQLiteProcedures = std::make_unique(); - this->dataScheduleMgr = std::make_unique(); - this->dataSetPointManager = std::make_unique(); - this->dataShadowComb = std::make_unique(); - this->dataSimAirServingZones = std::make_unique(); - this->dataSimulationManager = std::make_unique(); - this->dataSingleDuct = std::make_unique(); - this->dataSize = std::make_unique(); - this->dataSizingManager = std::make_unique(); - this->dataSolarCollectors = std::make_unique(); - this->dataSolarReflectionManager = std::make_unique(); - this->dataSolarShading = std::make_unique(); - this->dataSplitterComponent = std::make_unique(); - this->dataSteamBaseboardRadiator = std::make_unique(); - this->dataSteamCoils = std::make_unique(); - this->dataStrGlobals = std::make_unique(); - this->dataSurfColor = std::make_unique(); - this->dataSurfLists = std::make_unique(); - this->dataSurface = std::make_unique(); - this->dataSurfaceGeometry = std::make_unique(); - this->dataSurfaceGroundHeatExchangers = std::make_unique(); - this->dataSwimmingPools = std::make_unique(); - this->dataSysAirFlowSizer = std::make_unique(); - this->dataSysRpts = std::make_unique(); - this->dataSysVars = std::make_unique(); - this->dataAvail = std::make_unique(); - this->dataTARCOGCommon = std::make_unique(); - this->dataTARCOGOutputs = std::make_unique(); - this->dataThermalChimneys = std::make_unique(); - this->dataThermalComforts = std::make_unique(); - this->dataThermalISO15099Calc = std::make_unique(); - this->dataTARCOGGasses90 = std::make_unique(); - this->dataTARCOGMain = std::make_unique(); - this->dataTarcogShading = std::make_unique(); - this->dataTimingsData = std::make_unique(); - this->dataTranspiredCollector = std::make_unique(); - this->dataUFADManager = std::make_unique(); - this->dataUnitHeaters = std::make_unique(); - this->dataUnitVentilators = std::make_unique(); - this->dataUnitarySystems = std::make_unique(); - this->dataUserDefinedComponents = std::make_unique(); - this->dataUtilityRoutines = std::make_unique(); - this->dataVariableSpeedCoils = std::make_unique(); - this->dataVectors = std::make_unique(); - this->dataVentilatedSlab = std::make_unique(); - this->dataViewFactor = std::make_unique(); - this->dataWaterCoils = std::make_unique(); - this->dataWaterData = std::make_unique(); - this->dataWaterManager = std::make_unique(); - this->dataWaterThermalTanks = std::make_unique(); - this->dataWaterToAirHeatPump = std::make_unique(); - this->dataWaterToAirHeatPumpSimple = std::make_unique(); - this->dataWaterUse = std::make_unique(); - this->dataWeather = std::make_unique(); - this->dataWindTurbine = std::make_unique(); - this->dataWindowAC = std::make_unique(); - this->dataWindowComplexManager = std::make_unique(); - this->dataWindowEquivLayer = std::make_unique(); - this->dataWindowEquivalentLayer = std::make_unique(); - this->dataWindowManager = std::make_unique(); - this->dataWindowManagerExterior = std::make_unique(); - this->dataZoneAirLoopEquipmentManager = std::make_unique(); - this->dataZoneContaminantPredictorCorrector = std::make_unique(); - this->dataZoneCtrls = std::make_unique(); - this->dataZoneDehumidifier = std::make_unique(); - this->dataZoneEnergyDemand = std::make_unique(); - this->dataZoneEquip = std::make_unique(); - this->dataZoneEquipmentManager = std::make_unique(); - this->dataZonePlenum = std::make_unique(); - this->dataZoneTempPredictorCorrector = std::make_unique(); -} - -EnergyPlusData::~EnergyPlusData() = default; - -void EnergyPlusData::clear_state() -{ - this->ready = true; - this->init_state_called = false; - this->dataAirLoop->clear_state(); - this->dataAirLoopHVACDOAS->clear_state(); - this->dataAirSystemsData->clear_state(); - this->afn->clear_state(); - this->dataBSDFWindow->clear_state(); - this->dataBaseSizerFanHeatInputs->clear_state(); - this->dataBaseSizerScalableInputs->clear_state(); - this->dataBaseboardElectric->clear_state(); - this->dataBaseboardRadiator->clear_state(); - this->dataBoilerSteam->clear_state(); - this->dataBoilers->clear_state(); - this->dataBranchAirLoopPlant->clear_state(); - this->dataBranchInputManager->clear_state(); - this->dataBranchNodeConnections->clear_state(); - this->dataCHPElectGen->clear_state(); - this->dataCTElectricGenerator->clear_state(); - this->dataChilledCeilingPanelSimple->clear_state(); - this->dataChillerAbsorber->clear_state(); - this->dataChillerElectricEIR->clear_state(); - this->dataChillerExhaustAbsorption->clear_state(); - this->dataChillerGasAbsorption->clear_state(); - this->dataChillerIndirectAbsorption->clear_state(); - this->dataChillerReformulatedEIR->clear_state(); - this->dataChillerElectricASHRAE205->clear_state(); - this->dataCoilCooingDX->clear_state(); - this->dataCondenserLoopTowers->clear_state(); - this->dataConstruction->clear_state(); - this->dataContaminantBalance->clear_state(); - this->dataConvect->clear_state(); - this->dataConvergeParams->clear_state(); - this->dataCoolTower->clear_state(); - this->dataCostEstimateManager->clear_state(); - this->dataCrossVentMgr->clear_state(); - this->dataCurveManager->clear_state(); - this->dataDXCoils->clear_state(); - this->dataDXFEarClipping->clear_state(); - this->dataDaylightingDevices->clear_state(); - this->dataDaylightingDevicesData->clear_state(); - this->dataDayltg->clear_state(); - this->dataDefineEquipment->clear_state(); - this->dataDemandManager->clear_state(); - this->dataDesiccantDehumidifiers->clear_state(); - this->dataDispVentMgr->clear_state(); - this->dataDualDuct->clear_state(); - this->dataEIRFuelFiredHeatPump->clear_state(); - this->dataEIRPlantLoopHeatPump->clear_state(); - this->dataEMSMgr->clear_state(); - this->dataEarthTube->clear_state(); - this->dataEcoRoofMgr->clear_state(); - this->dataEconLifeCycleCost->clear_state(); - this->dataEconTariff->clear_state(); - this->dataElectBaseboardRad->clear_state(); - this->dataElectPwrSvcMgr->clear_state(); - this->dataEnvrn->clear_state(); - this->dataErrTracking->clear_state(); - this->dataEvapCoolers->clear_state(); - this->dataEvapFluidCoolers->clear_state(); - this->dataExteriorEnergyUse->clear_state(); - this->dataExternalInterface->clear_state(); - this->dataFanCoilUnits->clear_state(); - this->dataFans->clear_state(); - this->dataFaultsMgr->clear_state(); - this->dataFluidCoolers->clear_state(); - this->dataFluidProperties->clear_state(); - this->dataFourPipeBeam->clear_state(); - this->dataFuelCellElectGen->clear_state(); - this->dataFurnaces->clear_state(); - this->dataGeneral->clear_state(); - this->dataGeneralRoutines->clear_state(); - this->dataGenerator->clear_state(); - this->dataGeneratorFuelSupply->clear_state(); - this->dataGlobal->clear_state(); - this->dataGlobalNames->clear_state(); - this->dataGrndTempModelMgr->clear_state(); - this->dataGroundHeatExchanger->clear_state(); - this->dataHPWaterToWaterClg->clear_state(); - this->dataHPWaterToWaterHtg->clear_state(); - this->dataHPWaterToWaterSimple->clear_state(); - this->dataHVACAssistedCC->clear_state(); - this->dataHVACControllers->clear_state(); - this->dataHVACCooledBeam->clear_state(); - this->dataHVACCtrl->clear_state(); - this->dataHVACDXHeatPumpSys->clear_state(); - this->dataHVACDuct->clear_state(); - this->dataHVACGlobal->clear_state(); - this->dataHVACInterfaceMgr->clear_state(); - this->dataHVACMgr->clear_state(); - this->dataHVACMultiSpdHP->clear_state(); - this->dataHVACSingleDuctInduc->clear_state(); - this->dataHVACSizingSimMgr->clear_state(); - this->dataHVACStandAloneERV->clear_state(); - this->dataHVACUnitaryBypassVAV->clear_state(); - this->dataHVACVarRefFlow->clear_state(); - this->dataHWBaseboardRad->clear_state(); - this->dataHeatBal->clear_state(); - this->dataHeatBalAirMgr->clear_state(); - this->dataHeatBalFanSys->clear_state(); - this->dataHeatBalFiniteDiffMgr->clear_state(); - this->dataHeatBalHAMTMgr->clear_state(); - this->dataHeatBalIntHeatGains->clear_state(); - this->dataHeatBalIntRadExchg->clear_state(); - this->dataHeatBalMgr->clear_state(); - this->dataHeatBalSurf->clear_state(); - this->dataHeatBalSurfMgr->clear_state(); - this->dataHeatRecovery->clear_state(); - this->dataHeatingCoils->clear_state(); - this->dataHighTempRadSys->clear_state(); - this->dataHumidifiers->clear_state(); - this->dataHybridModel->clear_state(); - this->dataHybridUnitaryAC->clear_state(); - this->dataHysteresisPhaseChange->clear_state(); - this->dataICEngElectGen->clear_state(); - this->dataIPShortCut->clear_state(); - this->dataIceThermalStorage->clear_state(); - this->dataIndoorGreen->clear_state(); - this->dataInputProcessing->clear_state(); - this->dataIntegratedHP->clear_state(); - this->dataInternalHeatGains->clear_state(); - this->dataLoopNodes->clear_state(); - this->dataLowTempRadSys->clear_state(); - this->dataMaterial->clear_state(); - this->dataMatrixDataManager->clear_state(); - this->dataMircoturbElectGen->clear_state(); - this->dataMixedAir->clear_state(); - this->dataMixerComponent->clear_state(); - this->dataMoistureBalEMPD->clear_state(); - this->dataMstBal->clear_state(); - this->dataMstBalEMPD->clear_state(); - this->dataMundtSimMgr->clear_state(); - this->dataNodeInputMgr->clear_state(); - this->dataOutAirNodeMgr->clear_state(); - this->dataOutRptPredefined->clear_state(); - this->dataOutRptTab->clear_state(); - this->dataOutdoorAirUnit->clear_state(); - this->dataOutput->clear_state(); - this->dataOutputProcessor->clear_state(); - this->dataOutputReportTabularAnnual->clear_state(); - this->dataOutputReports->clear_state(); - this->dataOutsideEnergySrcs->clear_state(); - this->dataPackagedThermalStorageCoil->clear_state(); - this->dataPhotovoltaic->clear_state(); - this->dataPhotovoltaicState->clear_state(); - this->dataPhotovoltaicThermalCollector->clear_state(); - this->dataPipeHT->clear_state(); - this->dataPipes->clear_state(); - this->dataPlantCentralGSHP->clear_state(); - this->dataPlantChillers->clear_state(); - this->dataPlantCompTempSrc->clear_state(); - this->dataPlantCondLoopOp->clear_state(); - this->dataPlantHXFluidToFluid->clear_state(); - this->dataPlantLoadProfile->clear_state(); - this->dataPlantMgr->clear_state(); - this->dataPlantPipingSysMgr->clear_state(); - this->dataPlantPressureSys->clear_state(); - this->dataPlantUtilities->clear_state(); - this->dataPlantValves->clear_state(); - this->dataPlnt->clear_state(); - this->dataPluginManager->clear_state(); - this->dataPollution->clear_state(); - this->dataPondGHE->clear_state(); - this->dataPowerInductionUnits->clear_state(); - this->dataPsychrometrics->clear_state(); - this->dataPsychCache->clear_state(); - this->dataPumps->clear_state(); - this->dataPurchasedAirMgr->clear_state(); - this->dataRefrigCase->clear_state(); - this->dataReportFlag->clear_state(); - this->dataResultsFramework->clear_state(); - this->dataRetAirPathMrg->clear_state(); - this->dataExhAirSystemMrg->clear_state(); - this->dataExhCtrlSystemMrg->clear_state(); - this->dataRoomAir->clear_state(); - this->dataRoomAirModelTempPattern->clear_state(); - this->dataRoomAirflowNetModel->clear_state(); - this->dataRootFinder->clear_state(); - this->dataRptCoilSelection->clear_state(); - this->dataRuntimeLang->clear_state(); - this->dataRuntimeLangProcessor->clear_state(); - this->dataSQLiteProcedures->clear_state(); - this->dataScheduleMgr->clear_state(); - this->dataSetPointManager->clear_state(); - this->dataShadowComb->clear_state(); - this->dataSimAirServingZones->clear_state(); - this->dataSimulationManager->clear_state(); - this->dataSingleDuct->clear_state(); - this->dataSize->clear_state(); - this->dataSizingManager->clear_state(); - this->dataSolarCollectors->clear_state(); - this->dataSolarReflectionManager->clear_state(); - this->dataSolarShading->clear_state(); - this->dataSplitterComponent->clear_state(); - this->dataSteamBaseboardRadiator->clear_state(); - this->dataSteamCoils->clear_state(); - this->dataStrGlobals->clear_state(); - this->dataSurfColor->clear_state(); - this->dataSurfLists->clear_state(); - this->dataSurface->clear_state(); - this->dataSurfaceGeometry->clear_state(); - this->dataSurfaceGroundHeatExchangers->clear_state(); - this->dataSwimmingPools->clear_state(); - this->dataSysAirFlowSizer->clear_state(); - this->dataSysRpts->clear_state(); - this->dataSysVars->clear_state(); - this->dataAvail->clear_state(); - this->dataTARCOGCommon->clear_state(); - this->dataTARCOGOutputs->clear_state(); - this->dataThermalChimneys->clear_state(); - this->dataThermalComforts->clear_state(); - this->dataThermalISO15099Calc->clear_state(); - this->dataTARCOGGasses90->clear_state(); - this->dataTARCOGMain->clear_state(); - this->dataTarcogShading->clear_state(); - this->dataTimingsData->clear_state(); - this->dataTranspiredCollector->clear_state(); - this->dataUFADManager->clear_state(); - this->dataUnitHeaters->clear_state(); - this->dataUnitVentilators->clear_state(); - this->dataUnitarySystems->clear_state(); - this->dataUserDefinedComponents->clear_state(); - this->dataUtilityRoutines->clear_state(); - this->dataVariableSpeedCoils->clear_state(); - this->dataVectors->clear_state(); - this->dataVentilatedSlab->clear_state(); - this->dataViewFactor->clear_state(); - this->dataWaterCoils->clear_state(); - this->dataWaterData->clear_state(); - this->dataWaterManager->clear_state(); - this->dataWaterThermalTanks->clear_state(); - this->dataWaterToAirHeatPump->clear_state(); - this->dataWaterToAirHeatPumpSimple->clear_state(); - this->dataWaterUse->clear_state(); - this->dataWeather->clear_state(); - this->dataWindTurbine->clear_state(); - this->dataWindowAC->clear_state(); - this->dataWindowComplexManager->clear_state(); - this->dataWindowEquivLayer->clear_state(); - this->dataWindowEquivalentLayer->clear_state(); - this->dataWindowManager->clear_state(); - this->dataWindowManagerExterior->clear_state(); - this->dataZoneAirLoopEquipmentManager->clear_state(); - this->dataZoneContaminantPredictorCorrector->clear_state(); - this->dataZoneCtrls->clear_state(); - this->dataZoneDehumidifier->clear_state(); - this->dataZoneEnergyDemand->clear_state(); - this->dataZoneEquip->clear_state(); - this->dataZoneEquipmentManager->clear_state(); - this->dataZonePlenum->clear_state(); - this->dataZoneTempPredictorCorrector->clear_state(); - - this->files.debug.close(); - this->files.err_stream.reset(); - this->files.eso.close(); - this->files.mtr.close(); - this->files.mtr.close(); - this->files.shade.close(); - this->files.ssz.close(); - this->files.zsz.close(); -} - -void EnergyPlusData::init_state(EnergyPlusData &state) -{ - if (this->init_state_called) return; - this->init_state_called = true; - // The order in which we do this matters. We're going to try to - // do this in "topological" order meaning the first to go are the - // objects that do not reference any other objects, like fluids, - // schedules, curves, etc. - this->dataSimulationManager->init_state(state); // GetProjectData - this->dataFluidProperties->init_state(state); // GetFluidPropertiesData - this->dataPsychrometrics->init_state(state); // InitializePsychRoutines - - this->dataAirLoop->init_state(state); - this->dataAirLoopHVACDOAS->init_state(state); - this->dataAirSystemsData->init_state(state); - this->afn->init_state(state); - this->dataBSDFWindow->init_state(state); - this->dataBaseSizerFanHeatInputs->init_state(state); - this->dataBaseSizerScalableInputs->init_state(state); - this->dataBaseboardElectric->init_state(state); - this->dataBaseboardRadiator->init_state(state); - this->dataBoilerSteam->init_state(state); - this->dataBoilers->init_state(state); - this->dataBranchAirLoopPlant->init_state(state); - this->dataBranchInputManager->init_state(state); - this->dataBranchNodeConnections->init_state(state); - this->dataCHPElectGen->init_state(state); - this->dataCTElectricGenerator->init_state(state); - this->dataChilledCeilingPanelSimple->init_state(state); - this->dataChillerAbsorber->init_state(state); - this->dataChillerElectricEIR->init_state(state); - this->dataChillerExhaustAbsorption->init_state(state); - this->dataChillerGasAbsorption->init_state(state); - this->dataChillerIndirectAbsorption->init_state(state); - this->dataChillerReformulatedEIR->init_state(state); - this->dataChillerElectricASHRAE205->init_state(state); - this->dataCoilCooingDX->init_state(state); - this->dataCondenserLoopTowers->init_state(state); - this->dataConstruction->init_state(state); - this->dataContaminantBalance->init_state(state); - this->dataConvect->init_state(state); - this->dataConvergeParams->init_state(state); - this->dataCoolTower->init_state(state); - this->dataCostEstimateManager->init_state(state); - this->dataCrossVentMgr->init_state(state); - this->dataCurveManager->init_state(state); - this->dataDXCoils->init_state(state); - this->dataDXFEarClipping->init_state(state); - this->dataDaylightingDevices->init_state(state); - this->dataDaylightingDevicesData->init_state(state); - this->dataDayltg->init_state(state); - this->dataDefineEquipment->init_state(state); - this->dataDemandManager->init_state(state); - this->dataDesiccantDehumidifiers->init_state(state); - this->dataDispVentMgr->init_state(state); - this->dataDualDuct->init_state(state); - this->dataEIRFuelFiredHeatPump->init_state(state); - this->dataEIRPlantLoopHeatPump->init_state(state); - this->dataEMSMgr->init_state(state); - this->dataEarthTube->init_state(state); - this->dataEcoRoofMgr->init_state(state); - this->dataEconLifeCycleCost->init_state(state); - this->dataEconTariff->init_state(state); - this->dataElectBaseboardRad->init_state(state); - this->dataElectPwrSvcMgr->init_state(state); - this->dataEnvrn->init_state(state); - this->dataErrTracking->init_state(state); - this->dataEvapCoolers->init_state(state); - this->dataEvapFluidCoolers->init_state(state); - this->dataExteriorEnergyUse->init_state(state); - this->dataExternalInterface->init_state(state); - this->dataFanCoilUnits->init_state(state); - this->dataFans->init_state(state); - this->dataFaultsMgr->init_state(state); - this->dataFluidCoolers->init_state(state); - this->dataFourPipeBeam->init_state(state); - this->dataFuelCellElectGen->init_state(state); - this->dataFurnaces->init_state(state); - this->dataGeneral->init_state(state); - this->dataGeneralRoutines->init_state(state); - this->dataGenerator->init_state(state); - this->dataGeneratorFuelSupply->init_state(state); - this->dataGlobal->init_state(state); - this->dataGlobalNames->init_state(state); - this->dataGrndTempModelMgr->init_state(state); - this->dataGroundHeatExchanger->init_state(state); - this->dataHPWaterToWaterClg->init_state(state); - this->dataHPWaterToWaterHtg->init_state(state); - this->dataHPWaterToWaterSimple->init_state(state); - this->dataHVACAssistedCC->init_state(state); - this->dataHVACControllers->init_state(state); - this->dataHVACCooledBeam->init_state(state); - this->dataHVACCtrl->init_state(state); - this->dataHVACDXHeatPumpSys->init_state(state); - this->dataHVACDuct->init_state(state); - this->dataHVACGlobal->init_state(state); - this->dataHVACInterfaceMgr->init_state(state); - this->dataHVACMgr->init_state(state); - this->dataHVACMultiSpdHP->init_state(state); - this->dataHVACSingleDuctInduc->init_state(state); - this->dataHVACSizingSimMgr->init_state(state); - this->dataHVACStandAloneERV->init_state(state); - this->dataHVACUnitaryBypassVAV->init_state(state); - this->dataHVACVarRefFlow->init_state(state); - this->dataHWBaseboardRad->init_state(state); - this->dataHeatBal->init_state(state); - this->dataHeatBalAirMgr->init_state(state); - this->dataHeatBalFanSys->init_state(state); - this->dataHeatBalFiniteDiffMgr->init_state(state); - this->dataHeatBalHAMTMgr->init_state(state); - this->dataHeatBalIntHeatGains->init_state(state); - this->dataHeatBalIntRadExchg->init_state(state); - this->dataHeatBalMgr->init_state(state); - this->dataHeatBalSurf->init_state(state); - this->dataHeatBalSurfMgr->init_state(state); - this->dataHeatRecovery->init_state(state); - this->dataHeatingCoils->init_state(state); - this->dataHighTempRadSys->init_state(state); - this->dataHumidifiers->init_state(state); - this->dataHybridModel->init_state(state); - this->dataHybridUnitaryAC->init_state(state); - this->dataHysteresisPhaseChange->init_state(state); - this->dataICEngElectGen->init_state(state); - this->dataIPShortCut->init_state(state); - this->dataIceThermalStorage->init_state(state); - this->dataIndoorGreen->init_state(state); - this->dataInputProcessing->init_state(state); - this->dataIntegratedHP->init_state(state); - this->dataInternalHeatGains->init_state(state); - this->dataLoopNodes->init_state(state); - this->dataLowTempRadSys->init_state(state); - this->dataMaterial->init_state(state); - this->dataMatrixDataManager->init_state(state); - this->dataMircoturbElectGen->init_state(state); - this->dataMixedAir->init_state(state); - this->dataMixerComponent->init_state(state); - this->dataMoistureBalEMPD->init_state(state); - this->dataMstBal->init_state(state); - this->dataMstBalEMPD->init_state(state); - this->dataMundtSimMgr->init_state(state); - this->dataNodeInputMgr->init_state(state); - this->dataOutAirNodeMgr->init_state(state); - this->dataOutRptPredefined->init_state(state); - this->dataOutRptTab->init_state(state); - this->dataOutdoorAirUnit->init_state(state); - this->dataOutput->init_state(state); - this->dataOutputProcessor->init_state(state); - this->dataOutputReportTabularAnnual->init_state(state); - this->dataOutputReports->init_state(state); - this->dataOutsideEnergySrcs->init_state(state); - this->dataPackagedThermalStorageCoil->init_state(state); - this->dataPhotovoltaic->init_state(state); - this->dataPhotovoltaicState->init_state(state); - this->dataPhotovoltaicThermalCollector->init_state(state); - this->dataPipeHT->init_state(state); - this->dataPipes->init_state(state); - this->dataPlantCentralGSHP->init_state(state); - this->dataPlantChillers->init_state(state); - this->dataPlantCompTempSrc->init_state(state); - this->dataPlantCondLoopOp->init_state(state); - this->dataPlantHXFluidToFluid->init_state(state); - this->dataPlantLoadProfile->init_state(state); - this->dataPlantMgr->init_state(state); - this->dataPlantPipingSysMgr->init_state(state); - this->dataPlantPressureSys->init_state(state); - this->dataPlantUtilities->init_state(state); - this->dataPlantValves->init_state(state); - this->dataPlnt->init_state(state); - this->dataPluginManager->init_state(state); - this->dataPollution->init_state(state); - this->dataPondGHE->init_state(state); - this->dataPowerInductionUnits->init_state(state); - this->dataPsychCache->init_state(state); - this->dataPumps->init_state(state); - this->dataPurchasedAirMgr->init_state(state); - this->dataRefrigCase->init_state(state); - this->dataReportFlag->init_state(state); - this->dataResultsFramework->init_state(state); - this->dataRetAirPathMrg->init_state(state); - this->dataExhAirSystemMrg->init_state(state); - this->dataExhCtrlSystemMrg->init_state(state); - this->dataRoomAir->init_state(state); - this->dataRoomAirModelTempPattern->init_state(state); - this->dataRoomAirflowNetModel->init_state(state); - this->dataRootFinder->init_state(state); - this->dataRptCoilSelection->init_state(state); - this->dataRuntimeLang->init_state(state); - this->dataRuntimeLangProcessor->init_state(state); - this->dataSQLiteProcedures->init_state(state); - this->dataScheduleMgr->init_state(state); - this->dataSetPointManager->init_state(state); - this->dataShadowComb->init_state(state); - this->dataSimAirServingZones->init_state(state); - this->dataSingleDuct->init_state(state); - this->dataSize->init_state(state); - this->dataSizingManager->init_state(state); - this->dataSolarCollectors->init_state(state); - this->dataSolarReflectionManager->init_state(state); - this->dataSolarShading->init_state(state); - this->dataSplitterComponent->init_state(state); - this->dataSteamBaseboardRadiator->init_state(state); - this->dataSteamCoils->init_state(state); - this->dataStrGlobals->init_state(state); - this->dataSurfColor->init_state(state); - this->dataSurfLists->init_state(state); - this->dataSurface->init_state(state); - this->dataSurfaceGeometry->init_state(state); - this->dataSurfaceGroundHeatExchangers->init_state(state); - this->dataSwimmingPools->init_state(state); - this->dataSysAirFlowSizer->init_state(state); - this->dataSysRpts->init_state(state); - this->dataSysVars->init_state(state); - this->dataAvail->init_state(state); - this->dataTARCOGCommon->init_state(state); - this->dataTARCOGOutputs->init_state(state); - this->dataThermalChimneys->init_state(state); - this->dataThermalComforts->init_state(state); - this->dataThermalISO15099Calc->init_state(state); - this->dataTARCOGGasses90->init_state(state); - this->dataTARCOGMain->init_state(state); - this->dataTarcogShading->init_state(state); - this->dataTimingsData->init_state(state); - this->dataTranspiredCollector->init_state(state); - this->dataUFADManager->init_state(state); - this->dataUnitHeaters->init_state(state); - this->dataUnitVentilators->init_state(state); - this->dataUnitarySystems->init_state(state); - this->dataUserDefinedComponents->init_state(state); - this->dataUtilityRoutines->init_state(state); - this->dataVariableSpeedCoils->init_state(state); - this->dataVectors->init_state(state); - this->dataVentilatedSlab->init_state(state); - this->dataViewFactor->init_state(state); - this->dataWaterCoils->init_state(state); - this->dataWaterData->init_state(state); - this->dataWaterManager->init_state(state); - this->dataWaterThermalTanks->init_state(state); - this->dataWaterToAirHeatPump->init_state(state); - this->dataWaterToAirHeatPumpSimple->init_state(state); - this->dataWaterUse->init_state(state); - this->dataWeather->init_state(state); - this->dataWindTurbine->init_state(state); - this->dataWindowAC->init_state(state); - this->dataWindowComplexManager->init_state(state); - this->dataWindowEquivLayer->init_state(state); - this->dataWindowEquivalentLayer->init_state(state); - this->dataWindowManager->init_state(state); - this->dataWindowManagerExterior->init_state(state); - this->dataZoneAirLoopEquipmentManager->init_state(state); - this->dataZoneContaminantPredictorCorrector->init_state(state); - this->dataZoneCtrls->init_state(state); - this->dataZoneDehumidifier->init_state(state); - this->dataZoneEnergyDemand->init_state(state); - this->dataZoneEquip->init_state(state); - this->dataZoneEquipmentManager->init_state(state); - this->dataZonePlenum->init_state(state); - this->dataZoneTempPredictorCorrector->init_state(state); -} - -} // namespace EnergyPlus diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh-e b/src/EnergyPlus/Data/EnergyPlusData.hh-e deleted file mode 100644 index 02946596aa4..00000000000 --- a/src/EnergyPlus/Data/EnergyPlusData.hh-e +++ /dev/null @@ -1,586 +0,0 @@ -// EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois, -// The Regents of the University of California, through Lawrence Berkeley National Laboratory -// (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge -// National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other -// contributors. All rights reserved. -// -// NOTICE: This Software was developed under funding from the U.S. Department of Energy and the -// U.S. Government consequently retains certain rights. As such, the U.S. Government has been -// granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, -// worldwide license in the Software to reproduce, distribute copies to the public, prepare -// derivative works, and perform publicly and display publicly, and to permit others to do so. -// -// Redistribution and use in source and binary forms, with or without modification, are permitted -// provided that the following conditions are met: -// -// (1) Redistributions of source code must retain the above copyright notice, this list of -// conditions and the following disclaimer. -// -// (2) Redistributions in binary form must reproduce the above copyright notice, this list of -// conditions and the following disclaimer in the documentation and/or other materials -// provided with the distribution. -// -// (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, -// the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be -// used to endorse or promote products derived from this software without specific prior -// written permission. -// -// (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form -// without changes from the version obtained under this License, or (ii) Licensee makes a -// reference solely to the software portion of its product, Licensee must refer to the -// software as "EnergyPlus version X" software, where "X" is the version number Licensee -// obtained under this License and may not use a different name for the software. Except as -// specifically required in this Section (4), Licensee shall not use in a company name, a -// product name, in advertising, publicity, or other promotional activities any name, trade -// name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly -// similar designation, without the U.S. Department of Energy's prior written consent. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR -// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY -// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. - -#ifndef EnergyPlusData_hh_INCLUDED -#define EnergyPlusData_hh_INCLUDED - -// C++ Headers -#include -#include -#include - -// EnergyPlus Headers -#include -#include -#include - -namespace EnergyPlus { - -// forward declare all structs -struct AirLoopHVACDOASData; -struct AirSystemsData; -namespace AirflowNetwork { - struct Solver; -} // namespace AirflowNetwork -struct BSDFWindowData; -struct BaseSizerWithFanHeatInputsData; -struct BaseSizerWithScalableInputsData; -struct BaseboardElectricData; -struct BaseboardRadiatorData; -struct BoilerSteamData; -struct BoilersData; -struct BranchInputManagerData; -struct BranchNodeConnectionsData; -struct CTElectricGeneratorData; -struct ChilledCeilingPanelSimpleData; -struct ChillerAbsorberData; -struct ChillerElectricEIRData; -struct ChillerExhaustAbsorptionData; -struct ChillerGasAbsorptionData; -struct ChillerIndirectAbsoprtionData; -struct ChillerReformulatedEIRData; -struct ChillerElectricASHRAE205Data; -struct CoilCoolingDXData; -struct CondenserLoopTowersData; -struct ConstructionData; -struct ContaminantBalanceData; -struct ConvectionCoefficientsData; -struct ConvergParamsData; -struct CoolTowerData; -struct CostEstimateManagerData; -struct CrossVentMgrData; -struct CurveManagerData; -struct DXCoilsData; -struct DXFEarClippingData; -struct DataAirLoopData; -struct DataBranchAirLoopPlantData; -struct DataDaylightingDevicesData; -struct DataGlobal; -struct DataInputProcessing; -struct DataPlantData; -struct DataStringGlobalsData; -struct DataTimingsData; -struct DataWaterData; -struct DataZoneControlsData; -struct DataZoneEnergyDemandsData; -struct DataZoneEquipmentData; -struct DaylightingDevicesData; -struct DaylightingData; -struct DefineEquipData; -struct DemandManagerData; -struct DesiccantDehumidifiersData; -struct DisplacementVentMgrData; -struct DualDuctData; -struct EIRFuelFiredHeatPumpsData; -struct EIRPlantLoopHeatPumpsData; -struct EMSManagerData; -struct EarthTubeData; -struct EcoRoofManagerData; -struct EconomicLifeCycleCostData; -struct EconomicTariffData; -struct ElectPwrSvcMgrData; -struct ElectricBaseboardRadiatorData; -struct EnvironmentData; -struct ErrorTrackingData; -struct EvaporativeCoolersData; -struct EvaporativeFluidCoolersData; -struct ExteriorEnergyUseData; -struct ExternalInterfaceData; -struct FanCoilUnitsData; -struct FansData; -struct FaultsManagerData; -struct FluidCoolersData; -struct FluidData; -struct FourPipeBeamData; -struct FuelCellElectricGeneratorData; -struct FurnacesData; -struct GeneralData; -struct GeneralRoutinesData; -struct GeneratorFuelSupplyData; -struct GeneratorsData; -struct GlobalNamesData; -struct GroundHeatExchangerData; -struct GroundTemperatureManagerData; -struct HVACControllersData; -struct HVACCooledBeamData; -struct HVACCtrlData; -struct HVACDXHeatPumpSystemData; -struct HVACDuctData; -struct HVACGlobalsData; -struct HVACHXAssistedCoolingCoilData; -struct HVACInterfaceManagerData; -struct HVACManagerData; -struct HVACMultiSpeedHeatPumpData; -struct HVACSingleDuctInducData; -struct HVACSizingSimMgrData; -struct HVACStandAloneERVData; -struct HVACUnitaryBypassVAVData; -struct HVACVarRefFlowData; -struct HWBaseboardRadiatorData; -struct HeatBalFanSysData; -struct HeatBalFiniteDiffMgr; -struct HeatBalHAMTMgrData; -struct HeatBalInternalHeatGainsData; -struct HeatBalSurfData; -struct HeatBalSurfMgr; -struct HeatBalanceAirMgrData; -struct HeatBalanceData; -struct HeatBalanceIntRadExchgData; -struct HeatBalanceMgrData; -struct HeatPumpWaterToWaterCOOLINGData; -struct HeatPumpWaterToWaterHEATINGData; -struct HeatPumpWaterToWaterSimpleData; -struct HeatRecoveryData; -struct HeatingCoilsData; -struct HighTempRadiantSystemData; -struct HumidifiersData; -struct HybridModelData; -struct HybridUnitaryAirConditionersData; -struct HysteresisPhaseChangeData; -struct ICEngineElectricGeneratorData; -struct IPShortCutsData; -struct IceThermalStorageData; -struct IndoorGreenData; -struct IntegratedHeatPumpGlobalData; -struct InternalHeatGainsData; -struct LoopNodeData; -struct LowTempRadiantSystemData; -struct MaterialData; -struct MatrixDataManagerData; -struct MicroCHPElectricGeneratorData; -struct MicroturbineElectricGeneratorData; -struct MixedAirData; -struct MixerComponentData; -struct MoistureBalanceData; -struct MoistureBalanceEMPDData; -struct MoistureBalanceEMPDManagerData; -struct MundtSimMgrData; -struct NodeInputManagerData; -struct OutAirNodeManagerData; -struct OutdoorAirUnitData; -struct OutputProcessorData; -struct OutputReportPredefinedData; -struct OutputReportTabularAnnualData; -struct OutputReportTabularData; -struct OutputReportsData; -struct OutputsData; -struct OutsideEnergySourcesData; -struct PackagedThermalStorageCoilData; -struct PhotovoltaicStateData; -struct PhotovoltaicThermalCollectorsData; -struct PhotovoltaicsData; -struct PipeHeatTransferData; -struct PipesData; -struct PlantCentralGSHPData; -struct PlantChillersData; -struct PlantCompTempSrcData; -struct PlantCondLoopOperationData; -struct PlantHeatExchangerFluidToFluidData; -struct PlantLoadProfileData; -struct PlantMgrData; -struct PlantPipingSysMgrData; -struct PlantPressureSysData; -struct PlantUtilitiesData; -struct PlantValvesData; -struct PluginManagerData; -struct PollutionData; -struct PondGroundHeatExchangerData; -struct PoweredInductionUnitsData; -struct PsychrometricsData; -struct PsychrometricCacheData; -struct PumpsData; -struct PurchasedAirManagerData; -struct RefrigeratedCaseData; -struct ReportCoilSelectionData; -struct ReportFlagData; -struct ResultsFrameworkData; -struct ReturnAirPathMgr; -struct ExhaustAirSystemMgr; -struct ExhaustControlSystemMgr; -struct RoomAirModelAirflowNetworkData; -struct RoomAirModelData; -struct RoomAirModelUserTempPatternData; -struct RootFindingData; -struct RuntimeLanguageData; -struct RuntimeLanguageProcessorData; -struct SQLiteProceduresData; -struct ScheduleManagerData; -struct SetPointManagerData; -struct ShadowCombData; -struct SimAirServingZonesData; -struct SimulationManagerData; -struct SingleDuctData; -struct SizingData; -struct SizingManagerData; -struct SolarCollectorsData; -struct SolarReflectionManagerData; -struct SolarShadingData; -struct SplitterComponentData; -struct SteamBaseboardRadiatorData; -struct SteamCoilsData; -struct SurfaceColorData; -struct SurfaceGeometryData; -struct SurfaceGroundHeatExchangersData; -struct SurfaceListsData; -struct SurfacesData; -struct SwimmingPoolsData; -struct SystemAirFlowSizerData; -struct SystemAvailabilityManagerData; -struct SystemReportsData; -struct SystemVarsData; -struct TARCOGCommonData; -struct TARCOGOutputData; -struct ThermalChimneysData; -struct ThermalComfortsData; -struct ThermalISO15099CalcData; -struct TARCOGGasses90Data; -struct TARCOGMainData; -struct TarcogShadingData; -struct TranspiredCollectorData; -struct UFADManagerData; -struct UnitHeatersData; -struct UnitVentilatorsData; -struct UnitarySystemsData; -struct UserDefinedComponentsData; -struct UtilityRoutinesData; -struct VariableSpeedCoilsData; -struct VectorsData; -struct VentilatedSlabData; -struct ViewFactorInfoData; -struct WaterCoilsData; -struct WaterManagerData; -struct WaterThermalTanksData; -struct WaterToAirHeatPumpData; -struct WaterToAirHeatPumpSimpleData; -struct WaterUseData; -struct WeatherManagerData; -struct WindTurbineData; -struct WindowACData; -struct WindowComplexManagerData; -struct WindowEquivLayerData; -struct WindowEquivalentLayerData; -struct WindowManagerData; -struct WindowManagerExteriorData; -struct ZoneAirLoopEquipmentManagerData; -struct ZoneContaminantPredictorCorrectorData; -struct ZoneDehumidifierData; -struct ZoneEquipmentManagerData; -struct ZonePlenumData; -struct ZoneTempPredictorCorrectorData; - -struct EnergyPlusData : BaseGlobalStruct -{ - bool ready = true; - - IOFiles files; - - // module globals - std::unique_ptr dataAirLoopHVACDOAS; - std::unique_ptr dataAirSystemsData; - std::unique_ptr afn; - std::unique_ptr dataBSDFWindow; - std::unique_ptr dataBaseSizerFanHeatInputs; - std::unique_ptr dataBaseSizerScalableInputs; - std::unique_ptr dataBaseboardElectric; - std::unique_ptr dataBaseboardRadiator; - std::unique_ptr dataBoilerSteam; - std::unique_ptr dataBoilers; - std::unique_ptr dataBranchInputManager; - std::unique_ptr dataBranchNodeConnections; - std::unique_ptr dataCTElectricGenerator; - std::unique_ptr dataChilledCeilingPanelSimple; - std::unique_ptr dataChillerAbsorber; - std::unique_ptr dataChillerElectricEIR; - std::unique_ptr dataChillerExhaustAbsorption; - std::unique_ptr dataChillerGasAbsorption; - std::unique_ptr dataChillerIndirectAbsorption; - std::unique_ptr dataChillerReformulatedEIR; - std::unique_ptr dataChillerElectricASHRAE205; - std::unique_ptr dataCoilCooingDX; - std::unique_ptr dataCondenserLoopTowers; - std::unique_ptr dataConstruction; - std::unique_ptr dataContaminantBalance; - std::unique_ptr dataConvect; - std::unique_ptr dataConvergeParams; - std::unique_ptr dataCoolTower; - std::unique_ptr dataCostEstimateManager; - std::unique_ptr dataCrossVentMgr; - std::unique_ptr dataCurveManager; - std::unique_ptr dataDXCoils; - std::unique_ptr dataDXFEarClipping; - std::unique_ptr dataAirLoop; - std::unique_ptr dataBranchAirLoopPlant; - std::unique_ptr dataDaylightingDevicesData; - std::unique_ptr dataGlobal; - std::unique_ptr dataInputProcessing; - std::unique_ptr dataPlnt; - std::unique_ptr dataStrGlobals; - std::unique_ptr dataTimingsData; - std::unique_ptr dataWaterData; - std::unique_ptr dataZoneCtrls; - std::unique_ptr dataZoneEnergyDemand; - std::unique_ptr dataZoneEquip; - std::unique_ptr dataDaylightingDevices; - std::unique_ptr dataDayltg; - std::unique_ptr dataDefineEquipment; - std::unique_ptr dataDemandManager; - std::unique_ptr dataDesiccantDehumidifiers; - std::unique_ptr dataDispVentMgr; - std::unique_ptr dataDualDuct; - std::unique_ptr dataEIRFuelFiredHeatPump; - std::unique_ptr dataEIRPlantLoopHeatPump; - std::unique_ptr dataEMSMgr; - std::unique_ptr dataEarthTube; - std::unique_ptr dataEcoRoofMgr; - std::unique_ptr dataEconLifeCycleCost; - std::unique_ptr dataEconTariff; - std::unique_ptr dataElectPwrSvcMgr; - std::unique_ptr dataElectBaseboardRad; - std::unique_ptr dataEnvrn; - std::unique_ptr dataErrTracking; - std::unique_ptr dataEvapCoolers; - std::unique_ptr dataEvapFluidCoolers; - std::unique_ptr dataExteriorEnergyUse; - std::unique_ptr dataExternalInterface; - std::unique_ptr dataFanCoilUnits; - std::unique_ptr dataFans; - std::unique_ptr dataFaultsMgr; - std::unique_ptr dataFluidCoolers; - std::unique_ptr dataFluidProperties; - std::unique_ptr dataFourPipeBeam; - std::unique_ptr dataFuelCellElectGen; - std::unique_ptr dataFurnaces; - std::unique_ptr dataGeneral; - std::unique_ptr dataGeneralRoutines; - std::unique_ptr dataGeneratorFuelSupply; - std::unique_ptr dataGenerator; - std::unique_ptr dataGlobalNames; - std::unique_ptr dataGroundHeatExchanger; - std::unique_ptr dataGrndTempModelMgr; - std::unique_ptr dataHVACControllers; - std::unique_ptr dataHVACCooledBeam; - std::unique_ptr dataHVACCtrl; - std::unique_ptr dataHVACDXHeatPumpSys; - std::unique_ptr dataHVACDuct; - std::unique_ptr dataHVACGlobal; - std::unique_ptr dataHVACAssistedCC; - std::unique_ptr dataHVACInterfaceMgr; - std::unique_ptr dataHVACMgr; - std::unique_ptr dataHVACMultiSpdHP; - std::unique_ptr dataHVACSingleDuctInduc; - std::unique_ptr dataHVACSizingSimMgr; - std::unique_ptr dataHVACStandAloneERV; - std::unique_ptr dataHVACUnitaryBypassVAV; - std::unique_ptr dataHVACVarRefFlow; - std::unique_ptr dataHWBaseboardRad; - std::unique_ptr dataHeatBalFanSys; - std::unique_ptr dataHeatBalFiniteDiffMgr; - std::unique_ptr dataHeatBalHAMTMgr; - std::unique_ptr dataHeatBalIntHeatGains; - std::unique_ptr dataHeatBalSurf; - std::unique_ptr dataHeatBalSurfMgr; - std::unique_ptr dataHeatBalAirMgr; - std::unique_ptr dataHeatBal; - std::unique_ptr dataHeatBalIntRadExchg; - std::unique_ptr dataHeatBalMgr; - std::unique_ptr dataHPWaterToWaterClg; - std::unique_ptr dataHPWaterToWaterHtg; - std::unique_ptr dataHPWaterToWaterSimple; - std::unique_ptr dataHeatRecovery; - std::unique_ptr dataHeatingCoils; - std::unique_ptr dataHighTempRadSys; - std::unique_ptr dataHumidifiers; - std::unique_ptr dataHybridModel; - std::unique_ptr dataHybridUnitaryAC; - std::unique_ptr dataHysteresisPhaseChange; - std::unique_ptr dataICEngElectGen; - std::unique_ptr dataIPShortCut; - std::unique_ptr dataIceThermalStorage; - std::unique_ptr dataIndoorGreen; - std::unique_ptr dataIntegratedHP; - std::unique_ptr dataInternalHeatGains; - std::unique_ptr dataLoopNodes; - std::unique_ptr dataLowTempRadSys; - std::unique_ptr dataMaterial; - std::unique_ptr dataMatrixDataManager; - std::unique_ptr dataCHPElectGen; - std::unique_ptr dataMircoturbElectGen; - std::unique_ptr dataMixedAir; - std::unique_ptr dataMixerComponent; - std::unique_ptr dataMstBal; - std::unique_ptr dataMstBalEMPD; - std::unique_ptr dataMoistureBalEMPD; - std::unique_ptr dataMundtSimMgr; - std::unique_ptr dataNodeInputMgr; - std::unique_ptr dataOutAirNodeMgr; - std::unique_ptr dataOutdoorAirUnit; - std::unique_ptr dataOutputProcessor; - std::unique_ptr dataOutRptPredefined; - std::unique_ptr dataOutputReportTabularAnnual; - std::unique_ptr dataOutRptTab; - std::unique_ptr dataOutputReports; - std::unique_ptr dataOutput; - std::unique_ptr dataOutsideEnergySrcs; - std::unique_ptr dataPackagedThermalStorageCoil; - std::unique_ptr dataPhotovoltaicState; - std::unique_ptr dataPhotovoltaicThermalCollector; - std::unique_ptr dataPhotovoltaic; - std::unique_ptr dataPipeHT; - std::unique_ptr dataPipes; - std::unique_ptr dataPlantCentralGSHP; - std::unique_ptr dataPlantChillers; - std::unique_ptr dataPlantCompTempSrc; - std::unique_ptr dataPlantCondLoopOp; - std::unique_ptr dataPlantHXFluidToFluid; - std::unique_ptr dataPlantLoadProfile; - std::unique_ptr dataPlantMgr; - std::unique_ptr dataPlantPipingSysMgr; - std::unique_ptr dataPlantPressureSys; - std::unique_ptr dataPlantUtilities; - std::unique_ptr dataPlantValves; - std::unique_ptr dataPluginManager; - std::unique_ptr dataPollution; - std::unique_ptr dataPondGHE; - std::unique_ptr dataPowerInductionUnits; - std::unique_ptr dataPsychrometrics; - std::unique_ptr dataPsychCache; - std::unique_ptr dataPumps; - std::unique_ptr dataPurchasedAirMgr; - std::unique_ptr dataRefrigCase; - std::unique_ptr dataRptCoilSelection; - std::unique_ptr dataReportFlag; - std::unique_ptr dataResultsFramework; - std::unique_ptr dataRetAirPathMrg; - std::unique_ptr dataExhAirSystemMrg; - std::unique_ptr dataExhCtrlSystemMrg; - std::unique_ptr dataRoomAirflowNetModel; - std::unique_ptr dataRoomAir; - std::unique_ptr dataRoomAirModelTempPattern; - std::unique_ptr dataRootFinder; - std::unique_ptr dataRuntimeLang; - std::unique_ptr dataRuntimeLangProcessor; - std::unique_ptr dataSQLiteProcedures; - std::unique_ptr dataScheduleMgr; - std::unique_ptr dataSetPointManager; - std::unique_ptr dataShadowComb; - std::unique_ptr dataSimAirServingZones; - std::unique_ptr dataSimulationManager; - std::unique_ptr dataSingleDuct; - std::unique_ptr dataSize; - std::unique_ptr dataSizingManager; - std::unique_ptr dataSolarCollectors; - std::unique_ptr dataSolarReflectionManager; - std::unique_ptr dataSolarShading; - std::unique_ptr dataSplitterComponent; - std::unique_ptr dataSteamBaseboardRadiator; - std::unique_ptr dataSteamCoils; - std::unique_ptr dataSurfColor; - std::unique_ptr dataSurfaceGeometry; - std::unique_ptr dataSurfaceGroundHeatExchangers; - std::unique_ptr dataSurfLists; - std::unique_ptr dataSurface; - std::unique_ptr dataSwimmingPools; - std::unique_ptr dataSysAirFlowSizer; - std::unique_ptr dataAvail; - std::unique_ptr dataSysRpts; - std::unique_ptr dataSysVars; - std::unique_ptr dataTARCOGCommon; - std::unique_ptr dataTARCOGOutputs; - std::unique_ptr dataThermalChimneys; - std::unique_ptr dataThermalComforts; - std::unique_ptr dataThermalISO15099Calc; - std::unique_ptr dataTARCOGGasses90; - std::unique_ptr dataTARCOGMain; - std::unique_ptr dataTarcogShading; - std::unique_ptr dataTranspiredCollector; - std::unique_ptr dataUFADManager; - std::unique_ptr dataUnitHeaters; - std::unique_ptr dataUnitVentilators; - std::unique_ptr dataUnitarySystems; - std::unique_ptr dataUserDefinedComponents; - std::unique_ptr dataUtilityRoutines; - std::unique_ptr dataVariableSpeedCoils; - std::unique_ptr dataVectors; - std::unique_ptr dataVentilatedSlab; - std::unique_ptr dataViewFactor; - std::unique_ptr dataWaterCoils; - std::unique_ptr dataWaterManager; - std::unique_ptr dataWaterThermalTanks; - std::unique_ptr dataWaterToAirHeatPump; - std::unique_ptr dataWaterToAirHeatPumpSimple; - std::unique_ptr dataWaterUse; - std::unique_ptr dataWeather; - std::unique_ptr dataWindTurbine; - std::unique_ptr dataWindowAC; - std::unique_ptr dataWindowComplexManager; - std::unique_ptr dataWindowEquivLayer; - std::unique_ptr dataWindowEquivalentLayer; - std::unique_ptr dataWindowManager; - std::unique_ptr dataWindowManagerExterior; - std::unique_ptr dataZoneAirLoopEquipmentManager; - std::unique_ptr dataZoneContaminantPredictorCorrector; - std::unique_ptr dataZoneDehumidifier; - std::unique_ptr dataZoneEquipmentManager; - std::unique_ptr dataZonePlenum; - std::unique_ptr dataZoneTempPredictorCorrector; - - EnergyPlusData(); - ~EnergyPlusData(); - - // Cannot safely copy or delete this until we eradicate all remaining - // calls to IOFiles::getSingleton and IOFiles::setSingleton - EnergyPlusData(const EnergyPlusData &) = delete; - EnergyPlusData(EnergyPlusData &&) = delete; - - void init_state([[maybe_unused]] EnergyPlusData &state) override; - bool init_state_called = false; - - void clear_state() override; -}; - -} // namespace EnergyPlus -#endif diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 870bb5e0567..41b39fbb56f 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -102,6 +102,12 @@ namespace FluidProperties { // supplying the same data for concentrations of 0.0 and 1.0 only. // Temperature data has to be supplied in ascending order only. + constexpr int DefaultNumGlyTemps(33); // Temperature dimension of default glycol data + constexpr int DefaultNumGlyConcs(10); // Concentration dimension of default glycol data + constexpr int DefaultNumSteamTemps(111); // Temperature dimension of default steam data. + constexpr int DefaultNumSteamSuperheatedTemps(114); // Temperature dimension of default steam data. + constexpr int DefaultNumSteamSuperheatedPressure(114); // Temperature dimension of default steam data. + static constexpr std::array DefaultGlycolTemps = { -35.0, -30.0, -25.0, -20.0, -15.0, -10.0, -5.0, 0.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 75.0, 80.0, 85.0, 90.0, 95.0, 100.0, 105.0, 110.0, 115.0, 120.0, 125.0}; // 33 total temperature @@ -523,31 +529,23 @@ namespace FluidProperties { // Standard EnergyPlus methodology. Derived type portions are // allocated as necessary as the data is read into the program. - // Using/Aliasing - using namespace std::placeholders; // For use with 'std::bind' in Array initializers - // SUBROUTINE PARAMETER DEFINITIONS: Real64 constexpr PressToler(1.0); // Some reasonable value for comparisons - static constexpr std::string_view RoutineName("GetFluidPropertiesData: "); + static constexpr std::string_view routineName = "GetFluidPropertiesData"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Array1D_string Alphas; // Reads string value from input file - Array1D_string cAlphaFieldNames; // field names for alpha fields - Array1D_string cNumericFieldNames; // field names for numeric fields + Array1D_string cAlphaFields; // field names for alpha fields + Array1D_string cNumericFields; // field names for numeric fields int NumAlphas; // States which alpha value to read from a "Number" line Array1D Numbers; // brings in data from IP Array1D_bool lAlphaFieldBlanks; // logical for blank alpha fields Array1D_bool lNumericFieldBlanks; // logical for blank numeric fields int NumNumbers; // States which number value to read from a "Numbers" line int Status; // Either 1 "object found" or -1 "not found" (also used as temp) - int InData; - std::string TempsName; - bool FirstSHMatch; + bool ErrorsFound(false); std::string CurrentModuleObject; // for ease in renaming. - Real64 pTemp; - int j; - int FluidNum; // SUBROUTINE LOCAL DATA: @@ -561,40 +559,31 @@ namespace FluidProperties { auto &df = state.dataFluidProps; - df->NumOfRefrigerants = 0; - df->NumOfGlycols = 0; - + // This is here because of a unit test in HVACVRF:2358 + for (int i = 1; i <= df->refrigs.isize(); ++i) delete df->refrigs(i); + df->refrigs.clear(); + for (int i = 1; i <= df->glycolsRaw.isize(); ++i) delete df->glycolsRaw(i); + df->glycolsRaw.clear(); + for (int i = 1; i <= df->glycols.isize(); ++i) delete df->glycols(i); + df->glycols.clear(); + // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol - Array2D DefaultSteamSuperheatedEnthalpyData(DefaultNumSteamSuperheatedPressure, DefaultNumSteamSuperheatedTemps); + // Where are these things initialized? + Array2D DefaultSteamSuperheatedEnthalpyData(DefaultNumSteamSuperheatedPressure, DefaultNumSteamSuperheatedTemps); Array2D DefaultSteamSuperheatedDensityData(DefaultNumSteamSuperheatedPressure, DefaultNumSteamSuperheatedTemps); struct FluidTempData { // Members std::string Name; // Name of the temperature list - int NumOfTemps = 0; // Number of temperatures in a particular arry + int NumOfTemps = 0; // Number of temperatures in a particular arry Array1D Temps; // Temperature values (degrees C) }; - struct PressureSequence - { - // Members - Real64 Pressure = 0.0; - int InPtr = 0; - }; - - struct FluidData - { - // Members - std::string Name; - bool IsGlycol = false; - }; - // Object Data Array1D FluidTemps; - Array1D PressurePtr; - Array1D FluidNames; + int MaxAlphas = 0; int MaxNumbers = 0; @@ -635,32 +624,33 @@ namespace FluidProperties { } Alphas.allocate(MaxAlphas); - cAlphaFieldNames.allocate(MaxAlphas); + cAlphaFields.allocate(MaxAlphas); lAlphaFieldBlanks.allocate(MaxAlphas); Alphas = ""; - cAlphaFieldNames = ""; + cAlphaFields = ""; lAlphaFieldBlanks = false; Numbers.allocate(MaxNumbers); - cNumericFieldNames.allocate(MaxNumbers); + cNumericFields.allocate(MaxNumbers); lNumericFieldBlanks.allocate(MaxNumbers); Numbers = 0.0; - cNumericFieldNames = ""; + cNumericFields = ""; lNumericFieldBlanks = false; + // First things first, add refrigerant placeholder for Steam. + auto *steam = new RefrigProps; + steam->Name = "STEAM"; + df->refrigs.push_back(steam); + steam->Num = df->refrigs.isize(); + // Check to see if there is any FluidName input. If not, this is okay as // long as the user only desires to simulate loops with water. More than // one FluidName input is not allowed. CurrentModuleObject = "FluidProperties:Name"; int NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); - FluidNames.allocate(NumOfOptionalInput); - - // Get a count on the number of refrigerants and the number of glycols entered - // so that the main derived types can be allocated - FluidNum = 0; for (int Loop = 1; Loop <= NumOfOptionalInput; ++Loop) { state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, @@ -672,93 +662,73 @@ namespace FluidProperties { Status, lNumericFieldBlanks, lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - ++FluidNum; - FluidNames(FluidNum).Name = Alphas(1); - if (Util::SameString(Alphas(2), Refrig)) { - ++df->NumOfRefrigerants; - FluidNames(FluidNum).IsGlycol = false; - } else if (Util::SameString(Alphas(2), Glycol)) { - ++df->NumOfGlycols; - FluidNames(FluidNum).IsGlycol = true; + cAlphaFields, + cNumericFields); + + if (Alphas(2) == "REFRIGERANT") { + if (GetRefrigNum(state, Alphas(1)) == 0) { + auto *refrig = new RefrigProps; + refrig->Name = Alphas(1); + df->refrigs.push_back(refrig); + refrig->Num = df->refrigs.isize(); + } + } else if (Alphas(2) == "GLYCOL") { + if (GetGlycolNum(state, Alphas(1)) == 0) { + auto *glycol = new GlycolProps; + glycol->Name = Alphas(1); + df->glycols.push_back(glycol); + glycol->Num = df->glycols.isize(); + } } else { - ShowSevereError(state, format("{}{}=\"{}\", invalid type", RoutineName, CurrentModuleObject, Alphas(1))); - ShowContinueError(state, format("...entered value=\"{}, Only REFRIGERANT or GLYCOL allowed as {}", Alphas(2), cAlphaFieldNames(2))); + ShowSevereError(state, format("{}: {}=\"{}\", invalid type", routineName, CurrentModuleObject, Alphas(1))); + ShowContinueError(state, format("...entered value=\"{}, Only REFRIGERANT or GLYCOL allowed as {}", Alphas(2), cAlphaFields(2))); ErrorsFound = true; } } if (ErrorsFound) { - ShowFatalError(state, format("{} Previous errors in input cause program termination.", RoutineName)); - } - - if (df->NumOfRefrigerants + 1 > 0) { - df->RefrigData.allocate(df->NumOfRefrigerants + 1); - } - if (df->NumOfGlycols > 0) { - df->GlyRawData.allocate(df->NumOfGlycols); - } - - // Take the fluid names and assign them to the appropriate derived type - df->NumOfRefrigerants = 1; - df->NumOfGlycols = 0; - df->RefrigData(1).Name = "STEAM"; // Steam is a refrigerant? In which universe? - df->RefrigData(1).Num = 1; - df->RefrigData(1).used = 1; - - for (int Loop = 1; Loop <= FluidNum; ++Loop) { - if (!FluidNames(Loop).IsGlycol) { - ++df->NumOfRefrigerants; - df->RefrigData(df->NumOfRefrigerants).Name = FluidNames(Loop).Name; - df->RefrigData(df->NumOfRefrigerants).Num = df->NumOfRefrigerants; - } else if (FluidNames(Loop).IsGlycol) { - ++df->NumOfGlycols; - df->GlyRawData(df->NumOfGlycols).Name = FluidNames(Loop).Name; - df->GlyRawData(df->NumOfGlycols).Num = df->NumOfGlycols; - } + ShowFatalError(state, format("{}: Previous errors in input cause program termination.", routineName)); } - FluidNames.deallocate(); - - df->RefrigData(1).NumPsPoints = DefaultNumSteamTemps; - df->RefrigData(1).PsTemps.allocate(DefaultNumSteamTemps); - df->RefrigData(1).PsValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).NumHPoints = DefaultNumSteamTemps; - df->RefrigData(1).HTemps.allocate(DefaultNumSteamTemps); - df->RefrigData(1).HfValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).HfgValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).NumCpPoints = DefaultNumSteamTemps; - df->RefrigData(1).CpTemps.allocate(DefaultNumSteamTemps); - df->RefrigData(1).CpfValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).CpfgValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).NumRhoPoints = DefaultNumSteamTemps; - df->RefrigData(1).RhoTemps.allocate(DefaultNumSteamTemps); - df->RefrigData(1).RhofValues.allocate(DefaultNumSteamTemps); - df->RefrigData(1).RhofgValues.allocate(DefaultNumSteamTemps); - - df->RefrigData(1).PsTemps = DefaultSteamTemps; - df->RefrigData(1).PsValues = DefaultSteamPressData; - df->RefrigData(1).HTemps = DefaultSteamTemps; - df->RefrigData(1).HfValues = DefaultSteamEnthalpyFluidData; - df->RefrigData(1).HfgValues = DefaultSteamEnthalpyGasFluidData; - df->RefrigData(1).CpTemps = DefaultSteamTemps; - df->RefrigData(1).CpfValues = DefaultSteamCpFluidData; - df->RefrigData(1).CpfgValues = DefaultSteamCpGasFluidData; - df->RefrigData(1).RhoTemps = DefaultSteamTemps; - df->RefrigData(1).RhofValues = DefaultSteamDensityFluidData; - df->RefrigData(1).RhofgValues = DefaultSteamDensityGasFluidData; - - df->RefrigData(1).NumSuperTempPts = DefaultNumSteamSuperheatedTemps; - df->RefrigData(1).NumSuperPressPts = DefaultNumSteamSuperheatedPressure; - df->RefrigData(1).SHTemps.allocate(df->RefrigData(1).NumSuperTempPts); - df->RefrigData(1).SHPress.allocate(df->RefrigData(1).NumSuperPressPts); - df->RefrigData(1).HshValues.allocate(df->RefrigData(1).NumSuperPressPts, df->RefrigData(1).NumSuperTempPts); - df->RefrigData(1).RhoshValues.allocate(df->RefrigData(1).NumSuperPressPts, df->RefrigData(1).NumSuperTempPts); - df->RefrigData(1).SHTemps = DefaultSteamSuperheatedTemps; - df->RefrigData(1).SHPress = DefaultSteamSuperheatedPressData; - df->RefrigData(1).HshValues = DefaultSteamSuperheatedEnthalpyData; - df->RefrigData(1).RhoshValues = DefaultSteamSuperheatedDensityData; + // Initialize Steam + steam->NumPsPoints = DefaultNumSteamTemps; + steam->PsTemps.allocate(DefaultNumSteamTemps); + steam->PsValues.allocate(DefaultNumSteamTemps); + steam->NumHPoints = DefaultNumSteamTemps; + steam->HTemps.allocate(DefaultNumSteamTemps); + steam->HfValues.allocate(DefaultNumSteamTemps); + steam->HfgValues.allocate(DefaultNumSteamTemps); + steam->NumCpPoints = DefaultNumSteamTemps; + steam->CpTemps.allocate(DefaultNumSteamTemps); + steam->CpfValues.allocate(DefaultNumSteamTemps); + steam->CpfgValues.allocate(DefaultNumSteamTemps); + steam->NumRhoPoints = DefaultNumSteamTemps; + steam->RhoTemps.allocate(DefaultNumSteamTemps); + steam->RhofValues.allocate(DefaultNumSteamTemps); + steam->RhofgValues.allocate(DefaultNumSteamTemps); + + steam->PsTemps = DefaultSteamTemps; + steam->PsValues = DefaultSteamPressData; + steam->HTemps = DefaultSteamTemps; + steam->HfValues = DefaultSteamEnthalpyFluidData; + steam->HfgValues = DefaultSteamEnthalpyGasFluidData; + steam->CpTemps = DefaultSteamTemps; + steam->CpfValues = DefaultSteamCpFluidData; + steam->CpfgValues = DefaultSteamCpGasFluidData; + steam->RhoTemps = DefaultSteamTemps; + steam->RhofValues = DefaultSteamDensityFluidData; + steam->RhofgValues = DefaultSteamDensityGasFluidData; + + steam->NumSupTempPoints = DefaultNumSteamSuperheatedTemps; + steam->NumSupPressPoints = DefaultNumSteamSuperheatedPressure; + steam->SupTemps.allocate(steam->NumSupTempPoints); + steam->SupPress.allocate(steam->NumSupPressPoints); + steam->HshValues.allocate(steam->NumSupPressPoints, steam->NumSupTempPoints); + steam->RhoshValues.allocate(steam->NumSupPressPoints, steam->NumSupTempPoints); + steam->SupTemps = DefaultSteamSuperheatedTemps; + steam->SupPress = DefaultSteamSuperheatedPressData; + steam->HshValues = DefaultSteamSuperheatedEnthalpyData; + steam->RhoshValues = DefaultSteamSuperheatedDensityData; // Read in all of the temperature arrays in the input file FluidTemps.allocate(NumOfFluidTempArrays); @@ -766,7 +736,8 @@ namespace FluidProperties { CurrentModuleObject = "FluidProperties:Temperatures"; for (int Loop = 1; Loop <= NumOfFluidTempArrays; ++Loop) { - + auto &tempArray = FluidTemps(Loop); + state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, Loop, @@ -777,1442 +748,747 @@ namespace FluidProperties { Status, lNumericFieldBlanks, lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); + cAlphaFields, + cNumericFields); - FluidTemps(Loop).Name = Alphas(1); - FluidTemps(Loop).NumOfTemps = NumNumbers; + tempArray.Name = Alphas(1); + tempArray.NumOfTemps = NumNumbers; - FluidTemps(Loop).Temps.allocate(FluidTemps(Loop).NumOfTemps); - FluidTemps(Loop).Temps = Numbers({1, NumNumbers}); + tempArray.Temps.allocate(tempArray.NumOfTemps); + tempArray.Temps = Numbers({1, NumNumbers}); - for (int TempLoop = 2; TempLoop <= FluidTemps(Loop).NumOfTemps; ++TempLoop) { - if (FluidTemps(Loop).Temps(TempLoop) <= FluidTemps(Loop).Temps(TempLoop - 1)) { + for (int TempLoop = 2; TempLoop <= tempArray.NumOfTemps; ++TempLoop) { + if (tempArray.Temps(TempLoop) <= tempArray.Temps(TempLoop - 1)) { ShowSevereError( state, - format("{}{} name={}, lists must have data in ascending order", RoutineName, CurrentModuleObject, FluidTemps(Loop).Name)); + format("{}: {} name={}, lists must have data in ascending order", routineName, CurrentModuleObject, tempArray.Name)); ShowContinueError(state, format("First out of order occurrence at Temperature #({}) {{{:.R3}}} >= Temp({}) {{{:.R3}}}", TempLoop - 1, - FluidTemps(Loop).Temps(TempLoop - 1), + tempArray.Temps(TempLoop - 1), TempLoop, - FluidTemps(Loop).Temps(TempLoop))); + tempArray.Temps(TempLoop))); ErrorsFound = true; break; } } } - // *************** REFRIGERANTS *************** - // Go through each refrigerant found in the fluid names statement and read in the data - // Note that every valid fluid must have ALL of the necessary data or a fatal error will - // be produced. - for (int Loop = 2; Loop <= df->NumOfRefrigerants; ++Loop) { - - // For each property, cycle through all the valid input until the proper match is found. - - // ********** SATURATED DATA SECTION ********** - - // Get: ***** Saturation Pressure temperatures and data (fluidgas only) ***** - // This section added by S.J.Rees May 2002. - CurrentModuleObject = "FluidProperties:Saturated"; - TempsName = ""; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Pressure)) && - (Util::SameString(Alphas(3), GasFluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - TempsName = FluidTemps(TempLoop).Name; - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).NumPsPoints = FluidTemps(TempLoop).NumOfTemps; - df->RefrigData(Loop).PsTemps.allocate(df->RefrigData(Loop).NumPsPoints); - df->RefrigData(Loop).PsValues.allocate(df->RefrigData(Loop).NumPsPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumPsPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " - "same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # pressure points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumPsPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).PsTemps = FluidTemps(TempLoop).Temps; - df->RefrigData(Loop).PsValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated fluid gas/fluid pressure input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } - - // If it made it all the way to the last input occurrence and didn't find a match, - // then no sat press data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } - - } // ...end of DO loop through all of the input syntax trying to find saturation pressure for this refrigerant - - // Get: ***** ENTHALPY of SATURATED LIQUID ***** - CurrentModuleObject = "FluidProperties:Saturated"; - TempsName = ""; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && - (Util::SameString(Alphas(3), Fluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - TempsName = FluidTemps(TempLoop).Name; - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).NumHPoints = FluidTemps(TempLoop).NumOfTemps; - df->RefrigData(Loop).HTemps.allocate(df->RefrigData(Loop).NumHPoints); - df->RefrigData(Loop).HfValues.allocate(df->RefrigData(Loop).NumHPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumHPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowSevereError(state, - format("Temperature Name={}, Temperature array and saturated fluid enthalpy array must have the same " - "number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumHPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).HTemps = FluidTemps(TempLoop).Temps; - df->RefrigData(Loop).HfValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated fluid enthalpy input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } - - // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid enthalpy data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format(R"(No Saturated Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="Fluid".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } - - } // ...end of DO loop through all of the input syntax trying to find saturated fluid enthalpy for this refrigerant - - // Get: ***** ENTHALPY of SATURATED LIQUID/VAPOR ***** (difference between Hf and Hg, i.e. Hfg) - CurrentModuleObject = "FluidProperties:Saturated"; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy)) && - (Util::SameString(Alphas(3), GasFluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Temperatures for enthalpy fluid and gas/fluid points are not the same"); - ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); - ErrorsFound = true; - break; - } - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).HfgValues.allocate(df->RefrigData(Loop).NumHPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumHPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format("Temperature Name={}, Temperature array and saturated gas/fluid enthalpy array must have " - "the same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumHPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).HfgValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated gas/fluid enthalpy input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } - - // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g enthalpy data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, - format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties to be entered with {}="Enthalpy" and {}="FluidGas".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } - - } // ...end of DO loop through all of the input syntax trying to find saturated gas/fluid enthalpy for this refrigerant - - // Get: ***** SPECIFIC HEAT of SATURATED LIQUID ***** - CurrentModuleObject = "FluidProperties:Saturated"; - TempsName = ""; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && - (Util::SameString(Alphas(3), Fluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - TempsName = FluidTemps(TempLoop).Name; - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).NumCpPoints = FluidTemps(TempLoop).NumOfTemps; - df->RefrigData(Loop).CpTemps.allocate(df->RefrigData(Loop).NumCpPoints); - df->RefrigData(Loop).CpfValues.allocate(df->RefrigData(Loop).NumCpPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumCpPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowSevereError( - state, - format("Temperature Name={}, Temperature array and saturated fluid Cp array must have the same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # Cp points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumCpPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).CpTemps = FluidTemps(TempLoop).Temps; - df->RefrigData(Loop).CpfValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated fluid specific heat (Cp) input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } + // For each property, cycle through all the valid input until the proper match is found. + + // ********** SATURATED DATA SECTION ********** + + // Get: ***** Saturation Pressure temperatures and data (fluidgas only) ***** + // This section added by S.J.Rees May 2002. + CurrentModuleObject = "FluidProperties:Saturated"; + for (int InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid Cp data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, - format(R"(No Saturated Fluid Specific Heat found. Need properties to be entered with {}="SpecificHeat" and {}="Fluid".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } + state.dataInputProcessing->inputProcessor->getObjectItem(state, + CurrentModuleObject, + InData, + Alphas, + NumAlphas, + Numbers, + NumNumbers, + Status, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFields, + cNumericFields); - } // ...end of DO loop through all of the input syntax trying to find saturated fluid Cp for this refrigerant - - // Get: ***** SPECIFIC HEAT of SATURATED LIQUID/VAPOR ***** (difference between Cpf and Cpg, i.e. Cpfg) - CurrentModuleObject = "FluidProperties:Saturated"; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat)) && - (Util::SameString(Alphas(3), GasFluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Temperatures for specific heat fluid and gas/fluid points are not the same"); - ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); - ErrorsFound = true; - break; - } - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).CpfgValues.allocate(df->RefrigData(Loop).NumCpPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumCpPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, - format( - "Temperature Name={}, Temperature array and saturated gas/fluid Cp array must have the same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # Cp points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumCpPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).CpfgValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated gas/fluid specific heat (Cp) input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; + + auto *refrig = GetRefrig(state, Alphas(1)); + if (refrig == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); + ErrorsFound = true; + continue; + } - // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g Cp data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, - format( - R"(No Saturated Gas/Fluid Specific Heat found. Need properties to be entered with {}="SpecificHeat" and {}="FluidGas".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } + if (refrig->satTempArrayName != "" && refrig->satTempArrayName != Alphas(4)) { + ShowSevereCustomMessage(state, eoh, "Saturated temperature arrays are not the same for different properties"); + ErrorsFound = true; + continue; + } + refrig->satTempArrayName = Alphas(4); - } // ...end of DO loop through all of the input syntax trying to find saturated gas/fluid Cp for this refrigerant - - // Get: ***** DENSITY of SATURATED LIQUID ***** - CurrentModuleObject = "FluidProperties:Saturated"; - TempsName = ""; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && - (Util::SameString(Alphas(3), Fluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - TempsName = FluidTemps(TempLoop).Name; - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).NumRhoPoints = FluidTemps(TempLoop).NumOfTemps; - df->RefrigData(Loop).RhoTemps.allocate(df->RefrigData(Loop).NumRhoPoints); - df->RefrigData(Loop).RhofValues.allocate(df->RefrigData(Loop).NumRhoPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumRhoPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format("Temperature Name={}, Temperature array and saturated fluid density array must have the " - "same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # Density points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumRhoPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; - df->RefrigData(Loop).RhofValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated fluid density input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop - } + int tempArrayNum = Util::FindItemInList(Alphas(4), FluidTemps); + if (tempArrayNum == 0) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(4), Alphas(4)); + ErrorsFound = true; + continue; + } - // If it made it all the way to the last input occurrence and didn't find a match, then no sat fluid density data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format(R"(No Saturated Fluid Density found. Need properties to be entered with {}="Density" and {}="Fluid".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; + auto &tempArray = FluidTemps(tempArrayNum); + + // Make sure the number of points in the two arrays (temps and values) are the same + if (NumNumbers != tempArray.NumOfTemps) { + ShowSevereError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); + ShowContinueError(state, + format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " + "same number of points", + tempArray.Name)); + ShowContinueError(state, format("Temperature # points={} whereas {} # {} points={}", tempArray.NumOfTemps, refrig->Name, Alphas(2), NumNumbers)); + ErrorsFound = true; + break; // the TempLoop DO Loop + } + + if (Alphas(2) == "PRESSURE" && Alphas(3) == "FLUIDGAS") { + refrig->NumPsPoints = tempArray.NumOfTemps; + refrig->PsTemps.allocate(refrig->NumPsPoints); + refrig->PsValues.allocate(refrig->NumPsPoints); + refrig->PsTemps = tempArray.Temps; + refrig->PsValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "ENTHALPY" && Alphas(3) == "FLUID") { + refrig->NumHPoints = tempArray.NumOfTemps; + refrig->HTemps.allocate(refrig->NumHPoints); + refrig->HfValues.allocate(refrig->NumHPoints); + refrig->HTemps = tempArray.Temps; + refrig->HfValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "ENTHALPY" && Alphas(3) == "FLUIDGAS") { + refrig->NumHPoints = tempArray.NumOfTemps; + refrig->HfgValues.allocate(refrig->NumHPoints); + refrig->HfgValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "SPECIFICHEAT" && Alphas(3) == "FLUID") { + refrig->NumCpPoints = tempArray.NumOfTemps; + refrig->CpTemps.allocate(refrig->NumCpPoints); + refrig->CpfValues.allocate(refrig->NumCpPoints); + refrig->CpTemps = tempArray.Temps; + refrig->CpfValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "SPECIFICHEAT" && Alphas(3) == "FLUIDGAS") { + refrig->NumCpPoints = tempArray.NumOfTemps; + refrig->CpfgValues.allocate(refrig->NumCpPoints); + refrig->CpfgValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "DENSITY" && Alphas(3) == "FLUID") { + refrig->NumRhoPoints = tempArray.NumOfTemps; + refrig->RhoTemps.allocate(refrig->NumRhoPoints); + refrig->RhofValues.allocate(refrig->NumRhoPoints); + refrig->RhoTemps = tempArray.Temps; + refrig->RhofValues = Numbers({1, NumNumbers}); + + } else if (Alphas(2) == "DENSITY" && Alphas(3) == "FLUIDGAS") { + refrig->NumRhoPoints = tempArray.NumOfTemps; + refrig->RhofgValues.allocate(refrig->NumRhoPoints); + refrig->RhofgValues = Numbers({1, NumNumbers}); + + } else if (Alphas(3) == "FLUID") { + if (Alphas(2) != "ENTHALPY" && Alphas(2) != "SPECIFICHEAT" && Alphas(2) != "DENSITY") { + ShowWarningError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); + ShowContinueError(state, format(R"({}="FLUID", but {}="{}" is not valid.)", cAlphaFields(3), cAlphaFields(2), Alphas(2))); + ShowContinueError(state, format(R"(Valid choices are "Enthalpy", "SpecificHeat", "Density".)")); + ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); } - - } // ...end of DO loop through all of the input syntax trying to find saturated fluid enthalpy for this refrigerant - - // Get: ***** DENSITY of SATURATED LIQUID/VAPOR ***** (difference between Rhof and Rhog, i.e. Rhofg) - CurrentModuleObject = "FluidProperties:Saturated"; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density)) && - (Util::SameString(Alphas(3), GasFluid))) { - - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - - if (Util::SameString(Alphas(4), FluidTemps(TempLoop).Name)) { - if (!Util::SameString(FluidTemps(TempLoop).Name, TempsName)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Temperatures for density fluid and gas/fluid points are not the same"); - ShowContinueError(state, format("Name={} => {} /= {}", Alphas(4), FluidTemps(TempLoop).Name, TempsName)); - ErrorsFound = true; - break; - } - // At this point, we have found the correct input line and found a match - // for the temperature array. It's time to load up the local derived type. - df->RefrigData(Loop).RhofgValues.allocate(df->RefrigData(Loop).NumRhoPoints); - - // Make sure the number of points in the two arrays (temps and values) are the same - if (NumNumbers != df->RefrigData(Loop).NumRhoPoints) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, - format("Temperature Name={}, Temperature array and saturated gas/fluid density array must have the " - "same number of points", - TempsName)); - ShowContinueError(state, - format("Temperature # points={} whereas {} # density points={}", - NumNumbers, - df->RefrigData(Loop).Name, - df->RefrigData(Loop).NumRhoPoints)); - ErrorsFound = true; - break; // the TempLoop DO Loop - } - - // Same number of points so assign the values - df->RefrigData(Loop).RhofgValues = Numbers({1, NumNumbers}); - - break; // the TempLoop DO loop - } - - // If it made it all the way to the last temperature array and didn't find a match, then no match was found - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Found saturated gas/fluid density input but no matching temperature array"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } - - } // ...end of FluidTemps DO loop - - break; // the InData DO loop + + } else if (Alphas(3) == "FLUIDGAS") { + if (Alphas(2) != "PRESSURE" && Alphas(2) != "ENTHALPY" && Alphas(2) != "SPECIFICHEAT" && Alphas(2) != "DENSITY") { + ShowWarningError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); + ShowContinueError(state, format(R"({}="FluidGas", but {}="{}" is not valid.)", cAlphaFields(3), cAlphaFields(2), Alphas(2))); + ShowContinueError(state, format(R"(Valid choices are "Pressure", "Enthalpy", "SpecificHeat", "Density".)")); + ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); } + } else { + ShowWarningError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); + ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFields(3), Alphas(3))); + ShowContinueError(state, format(R"(Valid choices are "Fluid", "GasFluid".)")); + ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); + } + } // for (inData) + - // If it made it all the way to the last input occurrence and didn't find a match, then no sat f/g density data found - if (InData == NumOfSatFluidPropArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowSevereError( - state, - format(R"(No Saturated Gas/Fluid Density found. Need properties to be entered with {}="Density" and {}="FluidGas".)", - cAlphaFieldNames(2), - cAlphaFieldNames(3))); - ErrorsFound = true; - } + for (auto const *refrig : df->refrigs) { - } // ...end of DO loop through all of the input syntax trying to find saturated gas/fluid density for this refrigerant - - // Check: TEMPERATURES for saturated density (must all be the same) - // IF (RefrigData(Loop)%NumCpPoints /= RefrigData(Loop)%NumCpPoints) THEN - //!!! Error -- can never happen, does this mean NumCp vs. NumRho? - // CALL ShowFatalError(state, 'GetFluidPropertiesData: Number of specific heat fluid and gas/fluid points are not the same') - // ELSE - // DO TempLoop = 1, RefrigData(Loop)%NumCpPoints - //!!! Error -- something else that can never happen - // IF (ABS(RefrigData(Loop)%CpTemps(TempLoop)-RefrigData(Loop)%CpTemps(TempLoop)) > TempToler) THEN - // CALL ShowSevereError(state, 'GetFluidPropertiesData: Temperatures for specific heat fluid and '// & - // 'gas/fluid points are not the same') - // CALL ShowContinueError(state, 'Error occurs in Refrigerant Data Name='//TRIM(RefrigData(Loop)%Name)) - // WRITE(String1,*) TempLoop - // String1=ADJUSTL(String1) - // String2=TrimSigDigits(RefrigData(Loop)%CpTemps(TempLoop),3) - // String2=ADJUSTL(String2) - // String4=TrimSigDigits(RefrigData(Loop)%CpTemps(TempLoop),3) - // String4=ADJUSTL(String4) - // CALL ShowContinueError(state, 'First Occurrence at CpTemp('//TRIM(String1)//') {'//TRIM(String2)//'} /= - // {'//TRIM(String4)//'}') ErrorsFound=.TRUE. EXIT - // ENDIF - // END DO - // END IF - - // Error check on entering saturated data - int iTemp = 0; - CurrentModuleObject = "FluidProperties:Saturated"; - for (InData = 1; InData <= NumOfSatFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if (Util::SameString(Alphas(3), Fluid)) { - if (!Util::SameString(Alphas(2), Enthalpy) && !Util::SameString(Alphas(2), SpecificHeat) && - !Util::SameString(Alphas(2), Density)) { - if (iTemp == 0) { - ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); - ShowContinueError(state, format(R"(Valid choices are "{}", "{}", "{}".)", Enthalpy, SpecificHeat, Density)); - ShowContinueError(state, - "This fluid property will not be processed " - "mor available for the simulation."); - } - ++iTemp; - } - } else if (Util::SameString(Alphas(3), GasFluid)) { - if (!Util::SameString(Alphas(2), Pressure) && !Util::SameString(Alphas(2), Enthalpy) && - !Util::SameString(Alphas(2), SpecificHeat) && !Util::SameString(Alphas(2), Density)) { - if (iTemp == 0) { - ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError( - state, format(R"({}="{}", but {}="{}" is not valid.)", cAlphaFieldNames(3), Fluid, cAlphaFieldNames(2), Alphas(2))); - ShowContinueError(state, - format(R"(Valid choices are "{}", "{}", "{}", "{}".)", Pressure, Enthalpy, SpecificHeat, Density)); - ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); - } - ++iTemp; - } - } else { - if (iTemp == 0) { - ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(3), Alphas(3))); - ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Fluid, GasFluid)); - ShowContinueError(state, - "This fluid property will not be processed nor " - "available for the simulation."); - } - ++iTemp; - } + ErrorObjectHeader eoh{routineName, CurrentModuleObject, refrig->Name}; + if (refrig->PsValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } - if (iTemp > 1) { - ShowWarningError(state, format("{}{} has {} similar errors to the previous.", RoutineName, CurrentModuleObject, iTemp - 1)); - } - - // ********** SUPERHEATED DATA SECTION ********** - // Get: ***** ENTHALPY of SUPERHEATED GAS ***** - // First find the number of pressure value syntax lines have been entered and - // make sure that all of the pressure input is linked to the same temperature list - CurrentModuleObject = "FluidProperties:Superheated"; - TempsName = ""; - FirstSHMatch = true; - int NumOfPressPts = 0; - for (InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { - ++NumOfPressPts; - if (FirstSHMatch) { - TempsName = Alphas(3); - FirstSHMatch = false; - } else { - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); - ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); - ErrorsFound = true; - } - } - } + if (refrig->HfValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="Fluid".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } - if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "No pressure data found for superheated enthalpy"); + + if (refrig->HfgValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); ErrorsFound = true; } - // Now allocate the arrays and read the data into the proper place - // First, allocate the temperature array and transfer the data from the FluidTemp array - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - df->RefrigData(Loop).NumSuperTempPts = FluidTemps(TempLoop).NumOfTemps; - df->RefrigData(Loop).SHTemps.allocate(df->RefrigData(Loop).NumSuperTempPts); - df->RefrigData(Loop).SHTemps = FluidTemps(TempLoop).Temps; - break; // the TempLoop DO loop - } - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "No match for temperature array name found with superheated enthalpy data"); - ShowContinueError(state, format("Entered Temperature Name={}", TempsName)); - ErrorsFound = true; - } + if (refrig->CpfValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="Fluid".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } - // Next, allocate the pressure related arrays - df->RefrigData(Loop).NumSuperPressPts = NumOfPressPts; - df->RefrigData(Loop).SHPress.allocate(df->RefrigData(Loop).NumSuperPressPts); - df->RefrigData(Loop).HshValues.allocate(df->RefrigData(Loop).NumSuperPressPts, - df->RefrigData(Loop).NumSuperTempPts); - - // Finally, get the pressure and enthalpy values from the user input - CurrentModuleObject = "FluidProperties:Superheated"; - NumOfPressPts = 0; - PressurePtr.allocate(NumOfSHFluidPropArrays); - for (InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Enthalpy))) { - ++NumOfPressPts; - if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); - ErrorsFound = true; - } - PressurePtr(NumOfPressPts).Pressure = Numbers(1); - PressurePtr(NumOfPressPts).InPtr = InData; - } + if (refrig->CpfgValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Gas/Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } - // Sort Pressure list - // insertionSort - for (InData = 2; InData <= NumOfPressPts; ++InData) { - pTemp = PressurePtr(InData).Pressure; - iTemp = PressurePtr(InData).InPtr; - j = InData - 1; - while (j >= 1 && PressurePtr(j).Pressure > pTemp) { - PressurePtr(j + 1).Pressure = PressurePtr(j).Pressure; - PressurePtr(j + 1).InPtr = PressurePtr(j).InPtr; - --j; - if (j == 0) break; - } - PressurePtr(j + 1).Pressure = pTemp; - PressurePtr(j + 1).InPtr = iTemp; - } - - for (InData = 1; InData <= NumOfPressPts; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - PressurePtr(InData).InPtr, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - df->RefrigData(Loop).SHPress(InData) = Numbers(1); - // a little error trapping - if (InData > 1) { - if (df->RefrigData(Loop).SHPress(InData) <= df->RefrigData(Loop).SHPress(InData - 1)) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Pressures must be entered in ascending order for fluid property data"); - ShowContinueError(state, - format("First Occurrence at Pressure({}) {{{:.3R}}} >= Pressure({}) {{{:.3R}}}", - InData - 1, - df->RefrigData(Loop).SHPress(InData - 1), - InData, - df->RefrigData(Loop).SHPress(InData))); - ErrorsFound = true; - break; - } - } - if ((NumNumbers - 1) == df->RefrigData(Loop).NumSuperTempPts) { - df->RefrigData(Loop).HshValues(InData, {1, df->RefrigData(Loop).NumSuperTempPts}) = - Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Number of superheated enthalpy data points not equal to number of temperature points"); - ErrorsFound = true; - } + if (refrig->RhofValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Fluid Density found. Need properties with {}="Density" and {}="Fluid".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } - PressurePtr.deallocate(); - - // Get: ***** DENSITY of SUPERHEATED GAS ***** - // First find the number of pressure value syntax lines have been entered and - // make sure that all of the pressure input is linked to the same temperature list - // Then allocate the arrays and read the data into the proper place - df->RefrigData(Loop).RhoshValues.allocate(df->RefrigData(Loop).NumSuperPressPts, - df->RefrigData(Loop).NumSuperTempPts); - CurrentModuleObject = "FluidProperties:Superheated"; - NumOfPressPts = 0; - PressurePtr.allocate(NumOfSHFluidPropArrays); - for (InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->RefrigData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { - ++NumOfPressPts; - if (Numbers(1) <= 0.0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); - ErrorsFound = true; - } - PressurePtr(NumOfPressPts).Pressure = Numbers(1); - PressurePtr(NumOfPressPts).InPtr = InData; - } + if (refrig->RhofgValues.size() == 0) { + ShowSevereCustomMessage(state, eoh, + format(R"(No Saturated Gas/Fluid Density found. Need properties with {}="Density" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); + ErrorsFound = true; } + } // for (refrigNum) + - // Sort Pressure list - // insertionSort - for (InData = 2; InData <= NumOfPressPts; ++InData) { - pTemp = PressurePtr(InData).Pressure; - iTemp = PressurePtr(InData).InPtr; - j = InData - 1; - while (j >= 1 && PressurePtr(j).Pressure > pTemp) { - PressurePtr(j + 1).Pressure = PressurePtr(j).Pressure; - PressurePtr(j + 1).InPtr = PressurePtr(j).InPtr; - --j; - if (j == 0) break; - } - PressurePtr(j + 1).Pressure = pTemp; - PressurePtr(j + 1).InPtr = iTemp; - } - - for (InData = 1; InData <= NumOfPressPts; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - PressurePtr(InData).InPtr, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if (std::abs(Numbers(1) - df->RefrigData(Loop).SHPress(InData)) > PressToler) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "All superheated data for the same refrigerant must use the same pressure data"); - ErrorsFound = true; - } - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "All superheated data for the same property must use the same temperature list"); - ErrorsFound = true; - } - if ((NumNumbers - 1) == df->RefrigData(Loop).NumSuperTempPts) { - df->RefrigData(Loop).RhoshValues(InData, {1, df->RefrigData(Loop).NumSuperTempPts}) = - Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, "Number of superheated density data points not equal to number of temperature points"); - ErrorsFound = true; - } + // Check: TEMPERATURES for saturated density (must all be the same) + // IF (RefrigData(Loop)%NumCpPoints /= RefrigData(Loop)%NumCpPoints) THEN + //!!! Error -- can never happen, does this mean NumCp vs. NumRho? + // CALL ShowFatalError(state, 'GetFluidPropertiesData: Number of specific heat fluid and gas/fluid points are not the same') + // ELSE + // DO TempLoop = 1, RefrigData(Loop)%NumCpPoints + //!!! Error -- something else that can never happen + // IF (ABS(RefrigData(Loop)%CpTemps(TempLoop)-RefrigData(Loop)%CpTemps(TempLoop)) > TempToler) THEN + // CALL ShowSevereError(state, 'GetFluidPropertiesData: Temperatures for specific heat fluid and '// & + // 'gas/fluid points are not the same') + // CALL ShowContinueError(state, 'Error occurs in Refrigerant Data Name='//TRIM(RefrigData(Loop)%Name)) + // WRITE(String1,*) TempLoop + // String1=ADJUSTL(String1) + // String2=TrimSigDigits(RefrigData(Loop)%CpTemps(TempLoop),3) + // String2=ADJUSTL(String2) + // String4=TrimSigDigits(RefrigData(Loop)%CpTemps(TempLoop),3) + // String4=ADJUSTL(String4) + // CALL ShowContinueError(state, 'First Occurrence at CpTemp('//TRIM(String1)//') {'//TRIM(String2)//'} /= + // {'//TRIM(String4)//'}') ErrorsFound=.TRUE. EXIT + // ENDIF + // END DO + // END IF + + // ********** SUPERHEATED DATA SECTION ********** + // Get: ***** ENTHALPY of SUPERHEATED GAS ***** + // First find the number of pressure value syntax lines have been entered and + // make sure that all of the pressure input is linked to the same temperature list + + // Need to do a setup pass to find the number of pressure points + CurrentModuleObject = "FluidProperties:Superheated"; + for (int InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { + state.dataInputProcessing->inputProcessor->getObjectItem(state, + CurrentModuleObject, + InData, + Alphas, + NumAlphas, + Numbers, + NumNumbers, + Status, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFields, + cNumericFields); + + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; + + auto *refrig = GetRefrig(state, Alphas(1)); + if (refrig == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); + ErrorsFound = true; + continue; + } + + if (refrig->supTempArrayName != "" && refrig->supTempArrayName != Alphas(3)) { + ShowSevereCustomMessage(state, eoh, "Saturated temperature arrays are not the same for different properties"); + ErrorsFound = true; + continue; } - PressurePtr.deallocate(); - - // Error check on entering superheated data - iTemp = 0; - CurrentModuleObject = "FluidProperties:Superheated"; - for (InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { - - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if (!Util::SameString(Alphas(2), Enthalpy) && !Util::SameString(Alphas(2), Density)) { - if (iTemp == 0) { - ShowWarningError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowContinueError(state, format("{}=\"{}\" is not valid.", cAlphaFieldNames(2), Alphas(2))); - ShowContinueError(state, format(R"(Valid choices are "{}", "{}".)", Enthalpy, Density)); - ShowContinueError(state, format("Pressure value of this item=[{:.2R}].", Numbers(1))); - ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); - } - ++iTemp; - } + refrig->supTempArrayName = Alphas(3); + + if (Alphas(2) != "ENTHALPY") + continue; + + int supTempArrayNum = Util::FindItemInList(refrig->supTempArrayName, FluidTemps); + if (supTempArrayNum == 0) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(3), Alphas(3)); + ErrorsFound = true; + continue; } - if (iTemp > 1) { - ShowWarningError(state, format("{}{} has {} similar errors to the previous.", RoutineName, CurrentModuleObject, iTemp - 1)); + auto &supTempArray = FluidTemps(supTempArrayNum); + refrig->NumSupTempPoints = supTempArray.NumOfTemps; + refrig->SupTemps.allocate(refrig->NumSupTempPoints); + refrig->SupTemps = supTempArray.Temps; + + if (Numbers(1) <= 0.0) { + ShowSevereError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); + ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); + ErrorsFound = true; + continue; } + + refrig->SupPress.push_back(Numbers(1)); + ++refrig->NumSupPressPoints; + } + + // Sort and allocate pressure point arrays + for (auto *refrig : df->refrigs) { + if (refrig->Name == "STEAM") continue; + + std::sort(refrig->SupPress.begin(), refrig->SupPress.end()); + + refrig->HshValues.allocate(refrig->NumSupPressPoints, refrig->NumSupTempPoints); + refrig->RhoshValues.allocate(refrig->NumSupPressPoints, refrig->NumSupTempPoints); + } + + // Finally, get the pressure and enthalpy values from the user input + CurrentModuleObject = "FluidProperties:Superheated"; + for (int InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { + state.dataInputProcessing->inputProcessor->getObjectItem(state, + CurrentModuleObject, + InData, + Alphas, + NumAlphas, + Numbers, + NumNumbers, + Status, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFields, + cNumericFields); - if (NumOfPressPts == 0) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowSevereError(state, "No pressure data found for superheated density"); + + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; + + auto *refrig = GetRefrig(state, Alphas(1)); + if (refrig == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); ErrorsFound = true; + continue; } - if (NumOfPressPts != df->RefrigData(Loop).NumSuperPressPts) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->RefrigData(Loop).Name)); - ShowSevereError(state, "Number of pressure points for superheated data different for enthalpy and density"); + + if ((NumNumbers - 1) != refrig->NumSupTempPoints) { + ShowSevereCustomMessage(state, eoh, + format("Number of superheated {} points ({}) not equal to number of temperature points ({})", + Alphas(2), NumNumbers - 1, refrig->NumSupTempPoints)); ErrorsFound = true; + continue; } + + // Find which pressure point this temperature series belongs to + auto pressFound = std::find(refrig->SupPress.begin(), refrig->SupPress.end(), Numbers(1)); + assert(pressFound != refrig->SupPress.end()); + int pressNum = (pressFound - refrig->SupPress.begin()) + 1; + + if (Alphas(2) == "ENTHALPY") { + refrig->HshValues(pressNum, {1, refrig->NumSupTempPoints}) = Numbers({2, NumNumbers}); + } else if (Alphas(2) == "DENSITY") { + refrig->RhoshValues(pressNum, {1, refrig->NumSupTempPoints}) = Numbers({2, NumNumbers}); + } else { + ShowWarningInvalidKey(state, eoh, cAlphaFields(2), Alphas(2), "", + format("Valid options are (\"Enthalpy\", \"Density\"). Fluid will not be available for simulation.")); + ErrorsFound = true; + continue; + } + } // for (InData) - } // ...end of DO loop through all of the refrigerants - - // *************** GLYCOLS *************** + + // *************** RAW GLYCOLS *************** // Go through each glycol found in the fluid names statement and read in the data // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. + + // Propylene and ethylene are available by default + auto *ethylene = new GlycolRawProps; + ethylene->Name = "ETHYLENEGLYCOL"; + df->glycolsRaw.push_back(ethylene); + ethylene->Num = df->glycolsRaw.isize(); + + // Specific Heat + ethylene->CpDataPresent = true; // Flag set when specific heat data is available + ethylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat + ethylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat + + // No ObjexxFCL templates for assigning std::array to Array1S, Probably want to covert these Array1D and 2D to std::vector eventually anyway + ethylene->CpTemps.allocate(ethylene->NumCpTempPoints); // Temperatures for specific heat of glycol + for (int i = 1; i <= ethylene->NumCpTempPoints; ++i) + ethylene->CpTemps(i) = DefaultGlycolTemps[i-1]; + + ethylene->CpConcs.allocate(ethylene->NumCpConcPoints); // Concentration for specific heat of glycol + for (int i = 1; i <= ethylene->NumCpConcPoints; ++i) + ethylene->CpConcs(i) = DefaultGlycolConcs[i-1]; + + ethylene->CpValues.allocate(ethylene->NumCpConcPoints, ethylene->NumCpTempPoints); // Specific heat data values + for (int i = 1; i <= ethylene->NumCpConcPoints; ++i) + for (int j = 1; j <= ethylene->NumCpTempPoints; ++j) + ethylene->CpValues(i, j) = DefaultEthGlyCpData[i-1][j-1]; + + // Density + ethylene->RhoDataPresent = true; + ethylene->NumRhoTempPoints = DefaultNumGlyTemps; + ethylene->NumRhoConcPoints = DefaultNumGlyConcs; + + ethylene->RhoTemps.allocate(ethylene->NumRhoTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= ethylene->NumRhoTempPoints; ++i) + ethylene->RhoTemps(i) = DefaultGlycolTemps[i-1]; + + ethylene->RhoConcs.allocate(ethylene->NumRhoConcPoints); // Concentration for density of glycol + for (int i = 1; i <= ethylene->NumRhoConcPoints; ++i) + ethylene->RhoConcs(i) = DefaultGlycolConcs[i-1]; + + ethylene->RhoValues.allocate(ethylene->NumRhoConcPoints, ethylene->NumRhoTempPoints); // Density data values + for (int i = 1; i <= ethylene->NumRhoConcPoints; ++i) + for (int j = 1; j <= ethylene->NumRhoTempPoints; ++j) + ethylene->RhoValues(i, j) = DefaultEthGlyRhoData[i-1][j-1]; + + // Conductivity + ethylene->CondDataPresent = true; + ethylene->NumCondTempPoints = DefaultNumGlyTemps; + ethylene->NumCondConcPoints = DefaultNumGlyConcs; + + ethylene->CondTemps.allocate(ethylene->NumCondTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= ethylene->NumCondTempPoints; ++i) + ethylene->CondTemps(i) = DefaultGlycolTemps[i-1]; + + ethylene->CondConcs.allocate(ethylene->NumCondConcPoints); // Concentration for density of glycol + for (int i = 1; i <= ethylene->NumCondConcPoints; ++i) + ethylene->CondConcs(i) = DefaultGlycolConcs[i-1]; + + ethylene->CondValues.allocate(ethylene->NumCondConcPoints, ethylene->NumCondTempPoints); // Density data values + for (int i = 1; i <= ethylene->NumCondConcPoints; ++i) + for (int j = 1; j <= ethylene->NumCondTempPoints; ++j) + ethylene->CondValues(i, j) = DefaultEthGlyCondData[i-1][j-1]; + + // Viscosity + ethylene->ViscDataPresent = true; + ethylene->NumViscTempPoints = DefaultNumGlyTemps; + ethylene->NumViscConcPoints = DefaultNumGlyConcs; + + ethylene->ViscTemps.allocate(ethylene->NumViscTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= ethylene->NumViscTempPoints; ++i) + ethylene->ViscTemps(i) = DefaultGlycolTemps[i-1]; + + ethylene->ViscConcs.allocate(ethylene->NumViscConcPoints); // Concentration for density of glycol + for (int i = 1; i <= ethylene->NumViscConcPoints; ++i) + ethylene->ViscConcs(i) = DefaultGlycolConcs[i-1]; + + ethylene->ViscValues.allocate(ethylene->NumViscConcPoints, ethylene->NumViscTempPoints); // Density data values + for (int i = 1; i <= ethylene->NumViscConcPoints; ++i) + for (int j = 1; j <= ethylene->NumViscTempPoints; ++j) + ethylene->ViscValues(i, j) = DefaultEthGlyViscData[i-1][j-1]; + + // Propylene + auto *propylene = new GlycolRawProps; + propylene->Name = "PROPYLENEGLYCOL"; + df->glycolsRaw.push_back(propylene); + propylene->Num = df->glycolsRaw.isize(); + + // Specific Heat + propylene->CpDataPresent = true; // Flag set when specific heat data is available + propylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat + propylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat + + // No ObjexxFCL templates for assigning std::array to Array1S, Probably want to covert these Array1D and 2D to std::vector eventually anyway + propylene->CpTemps.allocate(propylene->NumCpTempPoints); // Temperatures for specific heat of glycol + for (int i = 1; i <= propylene->NumCpTempPoints; ++i) + propylene->CpTemps(i) = DefaultGlycolTemps[i-1]; + + propylene->CpConcs.allocate(propylene->NumCpConcPoints); // Concentration for specific heat of glycol + for (int i = 1; i <= propylene->NumCpConcPoints; ++i) + propylene->CpConcs(i) = DefaultGlycolConcs[i-1]; + + propylene->CpValues.allocate(propylene->NumCpConcPoints, propylene->NumCpTempPoints); // Specific heat data values + for (int i = 1; i <= propylene->NumCpConcPoints; ++i) + for (int j = 1; j <= propylene->NumCpTempPoints; ++j) + propylene->CpValues(i, j) = DefaultPropGlyCpData[i-1][j-1]; + + // Density + propylene->RhoDataPresent = true; + propylene->NumRhoTempPoints = DefaultNumGlyTemps; + propylene->NumRhoConcPoints = DefaultNumGlyConcs; + + propylene->RhoTemps.allocate(propylene->NumRhoTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= propylene->NumRhoTempPoints; ++i) + propylene->RhoTemps(i) = DefaultGlycolTemps[i-1]; + + propylene->RhoConcs.allocate(propylene->NumRhoConcPoints); // Concentration for density of glycol + for (int i = 1; i <= propylene->NumRhoConcPoints; ++i) + propylene->RhoConcs(i) = DefaultGlycolConcs[i-1]; + + propylene->RhoValues.allocate(propylene->NumRhoConcPoints, propylene->NumRhoTempPoints); // Density data values + for (int i = 1; i <= propylene->NumRhoConcPoints; ++i) + for (int j = 1; j <= propylene->NumRhoTempPoints; ++j) + propylene->RhoValues(i, j) = DefaultPropGlyRhoData[i-1][j-1]; + + // Conductivity + propylene->CondDataPresent = true; + propylene->NumCondTempPoints = DefaultNumGlyTemps; + propylene->NumCondConcPoints = DefaultNumGlyConcs; + + propylene->CondTemps.allocate(propylene->NumCondTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= propylene->NumCondTempPoints; ++i) + propylene->CondTemps(i) = DefaultGlycolTemps[i-1]; + + propylene->CondConcs.allocate(propylene->NumCondConcPoints); // Concentration for density of glycol + for (int i = 1; i <= propylene->NumCondConcPoints; ++i) + propylene->CondConcs(i) = DefaultGlycolConcs[i-1]; + + propylene->CondValues.allocate(propylene->NumCondConcPoints, propylene->NumCondTempPoints); // Density data values + for (int i = 1; i <= propylene->NumCondConcPoints; ++i) + for (int j = 1; j <= propylene->NumCondTempPoints; ++j) + propylene->CondValues(i, j) = DefaultPropGlyCondData[i-1][j-1]; + + // Viscosity + propylene->ViscDataPresent = true; + propylene->NumViscTempPoints = DefaultNumGlyTemps; + propylene->NumViscConcPoints = DefaultNumGlyConcs; + + propylene->ViscTemps.allocate(propylene->NumViscTempPoints); // Temperatures for density of glycol + for (int i = 1; i <= propylene->NumViscTempPoints; ++i) + propylene->ViscTemps(i) = DefaultGlycolTemps[i-1]; + + propylene->ViscConcs.allocate(propylene->NumViscConcPoints); // Concentration for density of glycol + for (int i = 1; i <= propylene->NumViscConcPoints; ++i) + propylene->ViscConcs(i) = DefaultGlycolConcs[i-1]; + + propylene->ViscValues.allocate(propylene->NumViscConcPoints, propylene->NumViscTempPoints); // Density data values + for (int i = 1; i <= propylene->NumViscConcPoints; ++i) + for (int j = 1; j <= propylene->NumViscTempPoints; ++j) + propylene->ViscValues(i, j) = DefaultPropGlyViscData[i-1][j-1]; + + CurrentModuleObject = "FluidProperties:Concentration"; - for (int Loop = 1; Loop <= df->NumOfGlycols; ++Loop) { - - // Get: ***** SPECIFIC HEAT of GLYCOLS ***** - // First find the number of concentration value syntax lines have been entered and - // make sure that all of the concentration input is linked to the same temperature list - TempsName = ""; - FirstSHMatch = true; - int NumOfConcPts = 0; - df->GlyRawData(Loop).CpDataPresent = false; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { - ++NumOfConcPts; - if (FirstSHMatch) { - TempsName = Alphas(3); - FirstSHMatch = false; - } else { - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "All glycol specific heat data for the same glycol must use the same temperature list"); - ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); - ErrorsFound = true; - } - } - } + for (int InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant + state.dataInputProcessing->inputProcessor->getObjectItem(state, + CurrentModuleObject, + InData, + Alphas, + NumAlphas, + Numbers, + NumNumbers, + Status, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFields, + cNumericFields); + + if (Alphas(1) == "WATER") continue; // Is this the right thing to do? + + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; + + auto *glycolRaw = GetGlycolRaw(state, Alphas(1)); + if (glycolRaw == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); + ErrorsFound = true; + continue; } - if (NumOfConcPts > 0) { - // Now allocate the arrays and read the data into the proper place - // First, allocate the temperature array and transfer the data from the FluidTemp array - df->GlyRawData(Loop).CpDataPresent = true; - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - df->GlyRawData(Loop).NumCpTempPts = FluidTemps(TempLoop).NumOfTemps; - df->GlyRawData(Loop).CpTemps.allocate(df->GlyRawData(Loop).NumCpTempPts); - df->GlyRawData(Loop).CpTemps = FluidTemps(TempLoop).Temps; - break; // the TempLoop DO loop - } - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "No match for temperature array name found with glycol data"); - ErrorsFound = true; - } - } - // Next, allocate the specific heat related arrays - df->GlyRawData(Loop).NumCpConcPts = NumOfConcPts; - df->GlyRawData(Loop).CpConcs.allocate(df->GlyRawData(Loop).NumCpConcPts); - df->GlyRawData(Loop).CpValues.allocate(df->GlyRawData(Loop).NumCpConcPts, - df->GlyRawData(Loop).NumCpTempPts); - - // Finally, get the specific heat and concentration values from the user input - CurrentModuleObject = "FluidProperties:Concentration"; - NumOfConcPts = 0; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), SpecificHeat))) { - ++NumOfConcPts; - df->GlyRawData(Loop).CpConcs(NumOfConcPts) = Numbers(1); - // a little error trapping - if (NumOfConcPts == 1) { - if (df->GlyRawData(Loop).CpConcs(NumOfConcPts) < 0.0) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); - ErrorsFound = true; - } - } else { - if (df->GlyRawData(Loop).CpConcs(NumOfConcPts) <= - df->GlyRawData(Loop).CpConcs(NumOfConcPts - 1)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); - ErrorsFound = true; - } - } - if ((NumNumbers - 1) == df->GlyRawData(Loop).NumCpTempPts) { - df->GlyRawData(Loop).CpValues(NumOfConcPts, {1, df->GlyRawData(Loop).NumCpTempPts}) = - Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Number of specific heat data points not equal to number of temperature points"); - ErrorsFound = true; - } - } - } + if (Util::FindItemInList(Alphas(3), FluidTemps) == 0) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(3), Alphas(3)); + ErrorsFound = true; + continue; } - // Get: ***** DENSITY of GLYCOLS ***** - // First find the number of concentration value syntax lines have been entered and - // make sure that all of the concentration input is linked to the same temperature list - TempsName = ""; - FirstSHMatch = true; - NumOfConcPts = 0; - df->GlyRawData(Loop).RhoDataPresent = false; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for density are consistant - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { - ++NumOfConcPts; - if (FirstSHMatch) { - TempsName = Alphas(3); - FirstSHMatch = false; - } else { - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "All glycol density data for the same glycol must use the same temperature list"); - ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); - ErrorsFound = true; - } - } - } + + if (Numbers(1) < 0.0) { + ShowSevereCustomMessage(state, eoh, "Negative concentrations not allowed in fluid property input data"); + ErrorsFound = true; + continue; } - if (NumOfConcPts > 0) { - // Now allocate the arrays and read the data into the proper place - // First, allocate the temperature array and transfer the data from the FluidTemp array - df->GlyRawData(Loop).RhoDataPresent = true; - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - df->GlyRawData(Loop).NumRhoTempPts = FluidTemps(TempLoop).NumOfTemps; - df->GlyRawData(Loop).RhoTemps.allocate(df->GlyRawData(Loop).NumRhoTempPts); - df->GlyRawData(Loop).RhoTemps = FluidTemps(TempLoop).Temps; - break; // the TempLoop DO loop - } - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "No match for temperature array name found with glycol data"); - ErrorsFound = true; - } + + // Can temperatue and pressure points be different for different properties? Why is this allowed? + if (Alphas(2) == "SPECIFICHEAT") { + if (glycolRaw->CpTempArrayName != "" && glycolRaw->CpTempArrayName != Alphas(3)) { + ShowSevereCustomMessage(state, eoh, + format("All specific heat data for the same glycol must use the same temperature list" + "Expected name={}, Entered name={}", glycolRaw->CpTempArrayName, Alphas(3))); + ErrorsFound = true; + continue; } - - // Next, allocate the density related arrays - df->GlyRawData(Loop).NumRhoConcPts = NumOfConcPts; - df->GlyRawData(Loop).RhoConcs.allocate(df->GlyRawData(Loop).NumRhoConcPts); - df->GlyRawData(Loop).RhoValues.allocate(df->GlyRawData(Loop).NumRhoConcPts, - df->GlyRawData(Loop).NumRhoTempPts); - - // Finally, get the density and concentration values from the user input - NumOfConcPts = 0; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Density))) { - ++NumOfConcPts; - df->GlyRawData(Loop).RhoConcs(NumOfConcPts) = Numbers(1); - // a little error trapping - if (NumOfConcPts == 1) { - if (df->GlyRawData(Loop).RhoConcs(NumOfConcPts) < 0.0) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); - ErrorsFound = true; - } - } else { - if (df->GlyRawData(Loop).RhoConcs(NumOfConcPts) <= - df->GlyRawData(Loop).RhoConcs(NumOfConcPts - 1)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); - ErrorsFound = true; - } - } - if ((NumNumbers - 1) == df->GlyRawData(Loop).NumRhoTempPts) { - df->GlyRawData(Loop).RhoValues( - NumOfConcPts, {1, df->GlyRawData(Loop).NumRhoTempPts}) = Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Number of density data points not equal to number of temperature points"); - ErrorsFound = true; - } - } + glycolRaw->CpTempArrayName = Alphas(3); + + glycolRaw->CpConcs.push_back(Numbers(1)); + ++glycolRaw->NumCpConcPoints; + + } else if (Alphas(2) == "DENSITY") { + if (glycolRaw->RhoTempArrayName != "" && glycolRaw->RhoTempArrayName != Alphas(3)) { + ShowSevereCustomMessage(state, eoh, + format("All density data for the same glycol must use the same temperature list" + "Expected name={}, Entered name={}", glycolRaw->RhoTempArrayName, Alphas(3))); + ErrorsFound = true; + continue; } - } - // Get: ***** CONDUCTIVITY of GLYCOLS ***** - // First find the number of concentration value syntax lines have been entered and - // make sure that all of the concentration input is linked to the same temperature list - TempsName = ""; - FirstSHMatch = true; - NumOfConcPts = 0; - df->GlyRawData(Loop).CondDataPresent = false; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for conductivity are consistant - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { - ++NumOfConcPts; - if (FirstSHMatch) { - TempsName = Alphas(3); - FirstSHMatch = false; - } else { - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "All glycol conductivity data for the same glycol must use the same temperature list"); - ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); - ErrorsFound = true; - } - } + glycolRaw->CpTempArrayName = Alphas(3); + + glycolRaw->RhoConcs.push_back(Numbers(1)); + ++glycolRaw->NumRhoConcPoints; + + } else if (Alphas(2) == "CONDUCTIVITY") { + if (glycolRaw->CondTempArrayName != "" && glycolRaw->CondTempArrayName != Alphas(3)) { + ShowSevereCustomMessage(state, eoh, + format("All conductivity data for the same glycol must use the same temperature list" + "Expected name={}, Entered name={}", glycolRaw->CondTempArrayName, Alphas(3))); + ErrorsFound = true; + continue; } - } - if (NumOfConcPts > 0) { - // Now allocate the arrays and read the data into the proper place - // First, allocate the temperature array and transfer the data from the FluidTemp array - df->GlyRawData(Loop).CondDataPresent = true; - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - df->GlyRawData(Loop).NumCondTempPts = FluidTemps(TempLoop).NumOfTemps; - df->GlyRawData(Loop).CondTemps.allocate(df->GlyRawData(Loop).NumCondTempPts); - df->GlyRawData(Loop).CondTemps = FluidTemps(TempLoop).Temps; - break; // the TempLoop DO loop - } - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "No match for temperature array name found with glycol data"); - ErrorsFound = true; - } + glycolRaw->CondTempArrayName = Alphas(3); + + glycolRaw->CondConcs.push_back(Numbers(1)); + ++glycolRaw->NumCondConcPoints; + + } else if (Alphas(2) == "VISCOSITY") { + if (glycolRaw->ViscTempArrayName != "" && glycolRaw->ViscTempArrayName != Alphas(3)) { + ShowSevereCustomMessage(state, eoh, + format("All conductivity data for the same glycol must use the same temperature list" + "Expected name={}, Entered name={}", glycolRaw->ViscTempArrayName, Alphas(3))); + ErrorsFound = true; + continue; } + glycolRaw->ViscTempArrayName = Alphas(3); + + glycolRaw->ViscConcs.push_back(Numbers(1)); + ++glycolRaw->NumViscConcPoints; - // Next, allocate the conductivity related arrays - df->GlyRawData(Loop).NumCondConcPts = NumOfConcPts; - df->GlyRawData(Loop).CondConcs.allocate(df->GlyRawData(Loop).NumCondConcPts); - df->GlyRawData(Loop).CondValues.allocate(df->GlyRawData(Loop).NumCondConcPts, - df->GlyRawData(Loop).NumCondTempPts); - - // Finally, get the conductivity and concentration values from the user input - NumOfConcPts = 0; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Conductivity))) { - ++NumOfConcPts; - df->GlyRawData(Loop).CondConcs(NumOfConcPts) = Numbers(1); - // a little error trapping - if (NumOfConcPts == 1) { - if (df->GlyRawData(Loop).CondConcs(NumOfConcPts) < 0.0) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); - ErrorsFound = true; - } - } else { - if (df->GlyRawData(Loop).CondConcs(NumOfConcPts) <= - df->GlyRawData(Loop).CondConcs(NumOfConcPts - 1)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); - ErrorsFound = true; - } - } - if ((NumNumbers - 1) == df->GlyRawData(Loop).NumCondTempPts) { - df->GlyRawData(Loop).CondValues( - NumOfConcPts, {1, df->GlyRawData(Loop).NumCondTempPts}) = Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Number of conductivity data points not equal to number of temperature points"); - ErrorsFound = true; - } - } - } - } - // Get: ***** VISCOSITY of GLYCOLS ***** - // First find the number of concentration value syntax lines have been entered and - // make sure that all of the concentration input is linked to the same temperature list - TempsName = ""; - FirstSHMatch = true; - NumOfConcPts = 0; - df->GlyRawData(Loop).ViscDataPresent = false; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for viscosity are consistant - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { - ++NumOfConcPts; - if (FirstSHMatch) { - TempsName = Alphas(3); - FirstSHMatch = false; - } else { - if (!Util::SameString(TempsName, Alphas(3))) { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "All glycol viscosity data for the same glycol must use the same temperature list"); - ShowContinueError(state, format("Expected name={}, Entered name={}", TempsName, Alphas(3))); - ErrorsFound = true; - } - } - } + } else { + ShowSevereInvalidKey(state, eoh, cAlphaFields(2), Alphas(2), + "Valid options are (\"Specific Heat\", \"Density\", \"Conductivity\", \"Viscosity\")"); + ErrorsFound = true; } - if (NumOfConcPts > 0) { - df->GlyRawData(Loop).ViscDataPresent = true; - // Now allocate the arrays and read the data into the proper place - // First, allocate the temperature array and transfer the data from the FluidTemp array - for (int TempLoop = 1; TempLoop <= NumOfFluidTempArrays; ++TempLoop) { - if (Util::SameString(TempsName, FluidTemps(TempLoop).Name)) { - df->GlyRawData(Loop).NumViscTempPts = FluidTemps(TempLoop).NumOfTemps; - df->GlyRawData(Loop).ViscTemps.allocate(df->GlyRawData(Loop).NumViscTempPts); - df->GlyRawData(Loop).ViscTemps = FluidTemps(TempLoop).Temps; - break; // the TempLoop DO loop - } - if (TempLoop == NumOfFluidTempArrays) { - ShowSevereError(state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "No match for temperature array name found with glycol data"); - ErrorsFound = true; - } - } + } - // Next, allocate the viscosity related arrays - df->GlyRawData(Loop).NumViscConcPts = NumOfConcPts; - df->GlyRawData(Loop).ViscConcs.allocate(df->GlyRawData(Loop).NumViscConcPts); - df->GlyRawData(Loop).ViscValues.allocate(df->GlyRawData(Loop).NumViscConcPts, - df->GlyRawData(Loop).NumViscTempPts); - - // Finally, get the viscosity and concentration values from the user input - NumOfConcPts = 0; - CurrentModuleObject = "FluidProperties:Concentration"; - for (InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, - CurrentModuleObject, - InData, - Alphas, - NumAlphas, - Numbers, - NumNumbers, - Status, - lNumericFieldBlanks, - lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - if ((Util::SameString(Alphas(1), df->GlyRawData(Loop).Name)) && (Util::SameString(Alphas(2), Viscosity))) { - ++NumOfConcPts; - df->GlyRawData(Loop).ViscConcs(NumOfConcPts) = Numbers(1); - // a little error trapping - if (NumOfConcPts == 1) { - if (df->GlyRawData(Loop).ViscConcs(NumOfConcPts) < 0.0) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Negative concentrations not allowed in fluid property input data"); - ErrorsFound = true; - } - } else { - if (df->GlyRawData(Loop).ViscConcs(NumOfConcPts) <= - df->GlyRawData(Loop).ViscConcs(NumOfConcPts - 1)) { - ShowSevereError( - state, format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Concentrations must be entered in ascending order for fluid property data"); - ErrorsFound = true; - } - } - if ((NumNumbers - 1) == df->GlyRawData(Loop).NumViscTempPts) { - df->GlyRawData(Loop).ViscValues( - NumOfConcPts, {1, df->GlyRawData(Loop).NumViscTempPts}) = Numbers({2, NumNumbers}); - } else { - ShowSevereError(state, - format("{}{} Name={}", RoutineName, CurrentModuleObject, df->GlyRawData(Loop).Name)); - ShowContinueError(state, "Number of viscosity data points not equal to number of temperature points"); - ErrorsFound = true; - } - } + // Allocate and sort temp point/conc point arrays + for (auto *glycolRaw : df->glycolsRaw) { + + if (glycolRaw->Name == "ETHYLENEGLYCOL" || glycolRaw->Name == "PROPYLENEGLYCOL") continue; + + int cpTempArrayNum = Util::FindItemInList(glycolRaw->CpTempArrayName, FluidTemps); + auto &cpTempArray = FluidTemps(cpTempArrayNum); + glycolRaw->NumCpTempPoints = cpTempArray.NumOfTemps; + glycolRaw->CpTemps.allocate(glycolRaw->NumCpTempPoints); + glycolRaw->CpTemps = cpTempArray.Temps; + + glycolRaw->CpValues.allocate(glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints); + std::sort(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end()); + + int rhoTempArrayNum = Util::FindItemInList(glycolRaw->RhoTempArrayName, FluidTemps); + auto &rhoTempArray = FluidTemps(rhoTempArrayNum); + glycolRaw->NumRhoTempPoints = rhoTempArray.NumOfTemps; + glycolRaw->RhoTemps.allocate(glycolRaw->NumRhoTempPoints); + glycolRaw->RhoTemps = rhoTempArray.Temps; + + glycolRaw->RhoValues.allocate(glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints); + std::sort(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end()); + + int condTempArrayNum = Util::FindItemInList(glycolRaw->CondTempArrayName, FluidTemps); + auto &condTempArray = FluidTemps(condTempArrayNum); + glycolRaw->NumCondTempPoints = condTempArray.NumOfTemps; + glycolRaw->CondTemps.allocate(glycolRaw->NumCondTempPoints); + glycolRaw->CondTemps = condTempArray.Temps; + + glycolRaw->CondValues.allocate(glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints); + std::sort(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end()); + + int viscTempArrayNum = Util::FindItemInList(glycolRaw->ViscTempArrayName, FluidTemps); + auto &viscTempArray = FluidTemps(viscTempArrayNum); + glycolRaw->NumViscTempPoints = viscTempArray.NumOfTemps; + glycolRaw->ViscTemps.allocate(glycolRaw->NumViscTempPoints); + glycolRaw->ViscTemps = viscTempArray.Temps; + + glycolRaw->ViscValues.allocate(glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints); + std::sort(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end()); + } + + // Finally, get the specific heat and concentration values from the user input + CurrentModuleObject = "FluidProperties:Concentration"; + for (int InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { + state.dataInputProcessing->inputProcessor->getObjectItem(state, + CurrentModuleObject, + InData, + Alphas, + NumAlphas, + Numbers, + NumNumbers, + Status, + lNumericFieldBlanks, + lAlphaFieldBlanks, + cAlphaFields, + cNumericFields); + + if (Alphas(1) == "WATER") continue; // Is this the right thing to do? + + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; + auto *glycolRaw = GetGlycolRaw(state, Alphas(1)); + assert(glycolRaw != nullptr); // We've already tested for this, can just assert now + + if (Alphas(2) == "SPECIFICHEAT") { + if ((NumNumbers - 1) != glycolRaw->NumCpTempPoints) { + ShowSevereCustomMessage(state, eoh, + format("Number of specific heat points ({}) not equal to number of temperature points ({})", + NumNumbers - 1, glycolRaw->NumCpTempPoints)); + ErrorsFound = true; + continue; + } + auto concFound = std::find(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end(), Numbers(1)); + assert(concFound != glycolRaw->CpConcs.end()); + int concNum = (concFound - glycolRaw->CpConcs.begin()) + 1; + glycolRaw->CpValues(concNum, {1, glycolRaw->NumCpTempPoints}) = Numbers({2, NumNumbers}); + + } else if (Alphas(2) == "DENSITY") { + if ((NumNumbers - 1) != glycolRaw->NumRhoTempPoints) { + ShowSevereCustomMessage(state, eoh, + format("Number of density points ({}) not equal to number of temperature points ({})", + NumNumbers - 1, glycolRaw->NumRhoTempPoints)); + ErrorsFound = true; + continue; + } + auto concFound = std::find(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end(), Numbers(1)); + assert(concFound != glycolRaw->RhoConcs.end()); + int concNum = (concFound - glycolRaw->RhoConcs.begin()) + 1; + glycolRaw->RhoValues(concNum, {1, glycolRaw->NumRhoTempPoints}) = Numbers({2, NumNumbers}); + + } else if (Alphas(2) == "CONDUCTIVITY") { + if ((NumNumbers - 1) != glycolRaw->NumCondTempPoints) { + ShowSevereCustomMessage(state, eoh, + format("Number of conductivity points ({}) not equal to number of temperature points ({})", + NumNumbers - 1, glycolRaw->NumCondTempPoints)); + ErrorsFound = true; + continue; } + auto concFound = std::find(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end(), Numbers(1)); + assert(concFound != glycolRaw->CondConcs.end()); + int concNum = (concFound - glycolRaw->CondConcs.begin()) + 1; + glycolRaw->CondValues(concNum, {1, glycolRaw->NumCondTempPoints}) = Numbers({2, NumNumbers}); + + } else if (Alphas(2) == "VISCOSITY") { + if ((NumNumbers - 1) != glycolRaw->NumViscTempPoints) { + ShowSevereCustomMessage(state, eoh, + format("Number of viscosity points ({}) not equal to number of temperature points ({})", + NumNumbers - 1, glycolRaw->NumViscTempPoints)); + ErrorsFound = true; + continue; + } + auto concFound = std::find(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end(), Numbers(1)); + assert(concFound != glycolRaw->ViscConcs.end()); + int concNum = (concFound - glycolRaw->ViscConcs.begin()) + 1; + glycolRaw->ViscValues(concNum, {1, glycolRaw->NumViscTempPoints}) = Numbers({2, NumNumbers}); } - } // glycol loop + } // for (InData) // Get: ***** GLYCOL CONCENTRATIONS ***** // Read in the GlycolConcentrations input and then set the property data accordingly @@ -2245,42 +1521,54 @@ namespace FluidProperties { CurrentModuleObject = "FluidProperties:GlycolConcentration"; NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); - int NumOfGlyConcs = NumOfOptionalInput + 1; - df->GlycolData.allocate(NumOfGlyConcs); - - df->GlycolData(1).used = true; // mark Water as always used - - // First "glycol" is always pure water. Load data from default arrays - df->GlycolData(1).Name = "WATER"; - df->GlycolData(1).GlycolName = "WATER"; - df->GlycolData(1).Num = 1; - df->GlycolData(1).Concentration = 1.0; - df->GlycolData(1).CpDataPresent = true; - df->GlycolData(1).NumCpTempPts = DefaultNumGlyTemps; - df->GlycolData(1).RhoDataPresent = true; - df->GlycolData(1).NumRhoTempPts = DefaultNumGlyTemps; - df->GlycolData(1).CondDataPresent = true; - df->GlycolData(1).NumCondTempPts = DefaultNumGlyTemps; - df->GlycolData(1).ViscDataPresent = true; - df->GlycolData(1).NumViscTempPts = DefaultNumGlyTemps; - df->GlycolData(1).CpTemps.allocate(df->GlycolData(1).NumCpTempPts); - df->GlycolData(1).CpValues.allocate(df->GlycolData(1).NumCpTempPts); - df->GlycolData(1).RhoTemps.allocate(df->GlycolData(1).NumRhoTempPts); - df->GlycolData(1).RhoValues.allocate(df->GlycolData(1).NumRhoTempPts); - df->GlycolData(1).CondTemps.allocate(df->GlycolData(1).NumCondTempPts); - df->GlycolData(1).CondValues.allocate(df->GlycolData(1).NumCondTempPts); - df->GlycolData(1).ViscTemps.allocate(df->GlycolData(1).NumViscTempPts); - df->GlycolData(1).ViscValues.allocate(df->GlycolData(1).NumViscTempPts); - df->GlycolData(1).CpTemps = DefaultGlycolTemps; - df->GlycolData(1).CpValues = DefaultWaterCpData; - df->GlycolData(1).RhoTemps = DefaultGlycolTemps; - df->GlycolData(1).RhoValues = DefaultWaterRhoData; - df->GlycolData(1).CondTemps = DefaultGlycolTemps; - df->GlycolData(1).CondValues = DefaultWaterCondData; - df->GlycolData(1).ViscTemps = DefaultGlycolTemps; - df->GlycolData(1).ViscValues = DefaultWaterViscData; - - NumOfGlyConcs = 1; // Water is always available, everything else must be specified + auto *water = new GlycolProps; + water->Name = "WATER"; + water->GlycolName = ""; + water->used = true; // mark Water as always used + + df->glycols.push_back(water); + water->Num = df->glycols.isize(); + + water->Concentration = 1.0; + water->CpDataPresent = true; + water->NumCpTempPoints = DefaultNumGlyTemps; + water->RhoDataPresent = true; + water->NumRhoTempPoints = DefaultNumGlyTemps; + water->CondDataPresent = true; + water->NumCondTempPoints = DefaultNumGlyTemps; + water->ViscDataPresent = true; + water->NumViscTempPoints = DefaultNumGlyTemps; + water->CpTemps.allocate(water->NumCpTempPoints); + water->CpValues.allocate(water->NumCpTempPoints); + water->RhoTemps.allocate(water->NumRhoTempPoints); + water->RhoValues.allocate(water->NumRhoTempPoints); + water->CondTemps.allocate(water->NumCondTempPoints); + water->CondValues.allocate(water->NumCondTempPoints); + water->CondTempRatios.allocate(water->NumCondTempPoints); + water->ViscTemps.allocate(water->NumViscTempPoints); + water->ViscValues.allocate(water->NumViscTempPoints); + water->CpTemps = DefaultGlycolTemps; + water->CpValues = DefaultWaterCpData; + water->RhoTemps = DefaultGlycolTemps; + water->RhoValues = DefaultWaterRhoData; + water->CondTemps = DefaultGlycolTemps; + water->CondValues = DefaultWaterCondData; + water->ViscTemps = DefaultGlycolTemps; + water->ViscValues = DefaultWaterViscData; + + // This is a speed optimization. Maybe. + water->CpTempRatios.allocate(water->NumCpTempPoints); + for (int i = 1; i < water->NumCpTempPoints; ++i) + water->CpTempRatios(i) = (water->CpValues(i+1) - water->CpValues(i)) / (water->CpTemps(i+1) - water->CpTemps(i)); + water->RhoTempRatios.allocate(water->NumRhoTempPoints); + for (int i = 1; i < water->NumRhoTempPoints; ++i) + water->RhoTempRatios(i) = (water->RhoValues(i+1) - water->RhoValues(i)) / (water->RhoTemps(i+1) - water->RhoTemps(i)); + water->CondTempRatios.allocate(water->NumCondTempPoints); + for (int i = 1; i < water->NumCondTempPoints; ++i) + water->CondTempRatios(i) = (water->CondValues(i+1) - water->CondValues(i)) / (water->CondTemps(i+1) - water->CondTemps(i)); + water->ViscTempRatios.allocate(water->NumViscTempPoints); + for (int i = 1; i < water->NumCondTempPoints; ++i) + water->ViscTempRatios(i) = (water->ViscValues(i+1) - water->ViscValues(i)) / (water->ViscTemps(i+1) - water->ViscTemps(i)); for (int Loop = 1; Loop <= NumOfOptionalInput; ++Loop) { state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -2293,224 +1581,125 @@ namespace FluidProperties { Status, lNumericFieldBlanks, lAlphaFieldBlanks, - cAlphaFieldNames, - cNumericFieldNames); - bool GlycolFound = false; - if (Util::SameString(Alphas(2), EthyleneGlycol)) { - GlycolFound = true; - ++NumOfGlyConcs; - df->GlycolData(NumOfGlyConcs).Name = Alphas(1); - df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - - df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); - } else if (Util::SameString(Alphas(2), PropyleneGlycol)) { - GlycolFound = true; - ++NumOfGlyConcs; - df->GlycolData(NumOfGlyConcs).Name = Alphas(1); - df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(2); - } else if (Util::SameString(Alphas(2), "UserDefinedGlycolType")) { - for (InData = 1; InData <= df->NumOfGlycols; ++InData) { - if (Util::SameString(Alphas(3), df->GlyRawData(InData).Name)) { - GlycolFound = true; - break; // DO LOOP through user defined glycols - } - } - if (GlycolFound) { - ++NumOfGlyConcs; - df->GlycolData(NumOfGlyConcs).Name = Alphas(1); - df->GlycolData(NumOfGlyConcs).Num = NumOfGlyConcs; - df->GlycolData(NumOfGlyConcs).GlycolName = Alphas(3); - } else { - ShowSevereError(state, format("{}{}=\"{}\", invalid reference", RoutineName, CurrentModuleObject, Alphas(1))); - ShowContinueError(state, format("... not found in the FluidProperties:Name list: \"{}\".", Alphas(3))); - ErrorsFound = true; - } - } else { - ShowSevereError(state, format("{}{}=\"{}\", invalid field", RoutineName, CurrentModuleObject, Alphas(1))); - ShowContinueError(state, format("...{}=\"{}\".", cAlphaFieldNames(2), Alphas(2))); - ShowContinueError(state, "... Legal values are PropyleneGlycol, EthyleneGlycol or UserDefinedGlycolType."); - ErrorsFound = true; - } - if (!GlycolFound) continue; - df->GlycolData(NumOfGlyConcs).Concentration = Numbers(1); - } - - // Now initialize the rest of the data for the glycols - for (int Loop = 2; Loop <= NumOfGlyConcs; ++Loop) { - auto &glycol = df->GlycolData(Loop); - - // Check to see if glycol name is one of the defaults or is listed in the Fluid Name list - if (Util::SameString(glycol.GlycolName, EthyleneGlycol)) { - glycol.BaseGlycolIndex = EthyleneGlycolIndex; - } else if (Util::SameString(glycol.GlycolName, PropyleneGlycol)) { - glycol.BaseGlycolIndex = PropyleneGlycolIndex; - } else { - for (InData = 1; InData <= df->NumOfGlycols; ++InData) { - if (Util::SameString(glycol.GlycolName, df->GlyRawData(InData).Name)) { - glycol.BaseGlycolIndex = InData; - break; // DO LOOP through user defined glycols - } - } - } + cAlphaFields, + cNumericFields); - // Set the rest of the parameters... - if ((glycol.BaseGlycolIndex == EthyleneGlycolIndex) || - (glycol.BaseGlycolIndex == PropyleneGlycolIndex)) { - - glycol.CpDataPresent = true; - glycol.NumCpTempPts = DefaultNumGlyTemps; - glycol.RhoDataPresent = true; - glycol.NumRhoTempPts = DefaultNumGlyTemps; - glycol.CondDataPresent = true; - glycol.NumCondTempPts = DefaultNumGlyTemps; - glycol.ViscDataPresent = true; - glycol.NumViscTempPts = DefaultNumGlyTemps; - glycol.CpTemps.allocate(glycol.NumCpTempPts); - glycol.CpValues.allocate(glycol.NumCpTempPts); - glycol.RhoTemps.allocate(glycol.NumRhoTempPts); - glycol.RhoValues.allocate(glycol.NumRhoTempPts); - glycol.CondTemps.allocate(glycol.NumCondTempPts); - glycol.CondValues.allocate(glycol.NumCondTempPts); - glycol.ViscTemps.allocate(glycol.NumViscTempPts); - glycol.ViscValues.allocate(glycol.NumViscTempPts); - glycol.CpTemps = DefaultGlycolTemps; - glycol.RhoTemps = DefaultGlycolTemps; - glycol.CondTemps = DefaultGlycolTemps; - glycol.ViscTemps = DefaultGlycolTemps; - - if (glycol.BaseGlycolIndex == EthyleneGlycolIndex) { - InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyCpData, glycol.Concentration, glycol.CpValues); - InterpDefValuesForGlycolConc(state, DefaultGlycolConcs, DefaultEthGlyRhoData, glycol.Concentration, glycol.RhoValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultEthGlyCondData, - glycol.Concentration, - glycol.CondValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultEthGlyViscData, - glycol.Concentration, - glycol.ViscValues); - } else { // == PropyleneGlycolIndex - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultPropGlyCpData, - glycol.Concentration, - glycol.CpValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultPropGlyRhoData, - glycol.Concentration, - glycol.RhoValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultPropGlyCondData, - glycol.Concentration, - glycol.CondValues); - InterpDefValuesForGlycolConc(state, - DefaultGlycolConcs, - DefaultPropGlyViscData, - glycol.Concentration, - glycol.ViscValues); - } + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; - } else { // User-defined fluid - - int Index = glycol.BaseGlycolIndex; - - // Specific heat data: - if (df->GlyRawData(Index).CpDataPresent) { - glycol.CpDataPresent = true; - glycol.NumCpTempPts = df->GlyRawData(Index).NumCpTempPts; - glycol.CpTemps.allocate(glycol.NumCpTempPts); - glycol.CpValues.allocate(glycol.NumCpTempPts); - glycol.CpTemps = df->GlyRawData(Index).CpTemps; - InterpValuesForGlycolConc(state, - df->GlyRawData(Index).NumCpConcPts, - df->GlyRawData(Index).NumCpTempPts, - df->GlyRawData(Index).CpConcs, - df->GlyRawData(Index).CpValues, - glycol.Concentration, - glycol.CpValues); - } else { - ShowSevereError(state, format("{}Specific heat data not entered for a {}", RoutineName, CurrentModuleObject)); - ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); - ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); - ErrorsFound = true; - } + auto *glycol = GetGlycol(state, Alphas(1)); + if (glycol == nullptr) { // It appears that FluidProperties:Name is not necessary + glycol = new GlycolProps; + glycol->Name = Alphas(1); + df->glycols.push_back(glycol); + glycol->Num = df->glycols.isize(); + } - // Density data: - if (df->GlyRawData(Index).CpDataPresent) { - glycol.RhoDataPresent = true; - glycol.NumRhoTempPts = df->GlyRawData(Index).NumRhoTempPts; - glycol.RhoTemps.allocate(glycol.NumRhoTempPts); - glycol.RhoValues.allocate(glycol.NumRhoTempPts); - glycol.RhoTemps = df->GlyRawData(Index).RhoTemps; - InterpValuesForGlycolConc(state, - df->GlyRawData(Index).NumRhoConcPts, - df->GlyRawData(Index).NumRhoTempPts, - df->GlyRawData(Index).RhoConcs, - df->GlyRawData(Index).RhoValues, - glycol.Concentration, - glycol.RhoValues); - } else { - ShowSevereError(state, format("{}Density data not entered for a {}", RoutineName, CurrentModuleObject)); - ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); - ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); + GlycolRawProps *glycolRaw = nullptr; + + if (Alphas(2) == "ETHYLENEGLYCOL" || Alphas(2) == "PROPYLENEGLYCOL") { + glycol->GlycolName = Alphas(2); + glycolRaw = GetGlycolRaw(state, Alphas(2)); + assert(glycolRaw != nullptr); + } else if (Alphas(2) == "USERDEFINEDGLYCOLTYPE") { // Why can't this just be the name of the user-defined glycol? + glycol->GlycolName = Alphas(3); + glycolRaw = GetGlycolRaw(state, Alphas(3)); + if (glycolRaw == nullptr) { + ShowSevereItemNotFound(state, eoh, cAlphaFields(3), Alphas(3)); ErrorsFound = true; + continue; } + } else { + ShowSevereInvalidKey(state, eoh, cAlphaFields(2), Alphas(2)); + ErrorsFound = true; + continue; + } - // Conductivity data: - if (df->GlyRawData(Index).CondDataPresent) { - glycol.CondDataPresent = true; - glycol.NumCondTempPts = df->GlyRawData(Index).NumCondTempPts; - glycol.CondTemps.allocate(glycol.NumCondTempPts); - glycol.CondValues.allocate(glycol.NumCondTempPts); - glycol.CondTemps = df->GlyRawData(Index).CondTemps; - InterpValuesForGlycolConc(state, - df->GlyRawData(Index).NumCondConcPts, - df->GlyRawData(Index).NumCondTempPts, - df->GlyRawData(Index).CondConcs, - df->GlyRawData(Index).CondValues, - glycol.Concentration, - glycol.CondValues); - } else { - ShowSevereError(state, format("{}Conductivity data not entered for a {}", RoutineName, CurrentModuleObject)); - ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); - ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); - ErrorsFound = true; - } + // We're good to go + glycol->Concentration = Numbers(1); - // Viscosity data: - if (df->GlyRawData(Index).ViscDataPresent) { - glycol.ViscDataPresent = true; - glycol.NumViscTempPts = df->GlyRawData(Index).NumViscTempPts; - glycol.ViscTemps.allocate(glycol.NumViscTempPts); - glycol.ViscValues.allocate(glycol.NumViscTempPts); - glycol.ViscTemps = df->GlyRawData(Index).ViscTemps; - InterpValuesForGlycolConc(state, - df->GlyRawData(Index).NumViscConcPts, - df->GlyRawData(Index).NumViscTempPts, - df->GlyRawData(Index).ViscConcs, - df->GlyRawData(Index).ViscValues, - glycol.Concentration, - glycol.ViscValues); - } else { - ShowSevereError(state, format("{}Viscosity data not entered for a {}", RoutineName, CurrentModuleObject)); - ShowContinueError(state, "ALL data must be entered for user-defined glycols"); - ShowContinueError(state, format("Glycol mixture name = {}", glycol.Name)); - ShowContinueError(state, format("Glycol fluid name = {}", glycol.GlycolName)); - ErrorsFound = true; - } + glycol->CpDataPresent = glycolRaw->CpDataPresent; + if (!glycol->CpDataPresent) { + ShowSevereError(state, format("{}: Specific heat data not entered for a {}", routineName, CurrentModuleObject)); + ShowContinueError(state, "ALL data must be entered for user-defined glycols"); + ShowContinueError(state, format("Glycol mixture name = {}", glycol->Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol->GlycolName)); + ErrorsFound = true; + continue; + } + + glycol->NumCpTempPoints = glycolRaw->NumCpTempPoints; + glycol->CpTemps.allocate(glycol->NumCpTempPoints); + glycol->CpTemps({1, glycol->NumCpTempPoints}) = glycolRaw->CpTemps({1, glycolRaw->NumCpTempPoints}); + glycol->CpValues.allocate(glycol->NumCpTempPoints); + InterpValuesForGlycolConc(state, glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints, glycolRaw->CpConcs, glycolRaw->CpValues, + glycol->Concentration, glycol->CpValues); + + glycol->RhoDataPresent = glycolRaw->RhoDataPresent; + if (!glycol->RhoDataPresent) { + ShowSevereError(state, format("{}: density data not entered for a {}", routineName, CurrentModuleObject)); + ShowContinueError(state, "ALL data must be entered for user-defined glycols"); + ShowContinueError(state, format("Glycol mixture name = {}", glycol->Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol->GlycolName)); + ErrorsFound = true; + continue; + } + + glycol->NumRhoTempPoints = glycolRaw->NumRhoTempPoints; + glycol->RhoTemps.allocate(glycol->NumRhoTempPoints); + glycol->RhoTemps({1, glycol->NumRhoTempPoints}) = glycolRaw->RhoTemps({1, glycolRaw->NumRhoTempPoints}); + glycol->RhoValues.allocate(glycol->NumRhoTempPoints); + InterpValuesForGlycolConc(state, glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints, glycolRaw->RhoConcs, glycolRaw->RhoValues, + glycol->Concentration, glycol->RhoValues); + + glycol->CondDataPresent = glycolRaw->CondDataPresent; + if (!glycol->CondDataPresent) { + ShowSevereError(state, format("{}: conductivity data not entered for a {}", routineName, CurrentModuleObject)); + ShowContinueError(state, "ALL data must be entered for user-defined glycols"); + ShowContinueError(state, format("Glycol mixture name = {}", glycol->Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol->GlycolName)); + ErrorsFound = true; + continue; + } + + glycol->NumCondTempPoints = glycolRaw->NumCondTempPoints; + glycol->CondTemps.allocate(glycol->NumCondTempPoints); + glycol->CondTemps({1, glycol->NumCondTempPoints}) = glycolRaw->CondTemps({1, glycolRaw->NumCondTempPoints}); + glycol->CondValues.allocate(glycol->NumCondTempPoints); + InterpValuesForGlycolConc(state, glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints, glycolRaw->CondConcs, glycolRaw->CondValues, + glycol->Concentration, glycol->CondValues); + + glycol->ViscDataPresent = glycolRaw->ViscDataPresent; + if (!glycol->ViscDataPresent) { + ShowSevereError(state, format("{}: viscosity data not entered for a {}", routineName, CurrentModuleObject)); + ShowContinueError(state, "ALL data must be entered for user-defined glycols"); + ShowContinueError(state, format("Glycol mixture name = {}", glycol->Name)); + ShowContinueError(state, format("Glycol fluid name = {}", glycol->GlycolName)); + ErrorsFound = true; + continue; } - } - - df->NumOfGlycols = NumOfGlyConcs; // Reset number of glycols to actual number - + + glycol->NumViscTempPoints = glycolRaw->NumViscTempPoints; + glycol->ViscTemps.allocate(glycol->NumViscTempPoints); + glycol->ViscTemps({1, glycol->NumViscTempPoints}) = glycolRaw->ViscTemps({1, glycolRaw->NumViscTempPoints}); + glycol->ViscValues.allocate(glycol->NumViscTempPoints); + InterpValuesForGlycolConc(state, glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints, glycolRaw->ViscConcs, glycolRaw->ViscValues, + glycol->Concentration, glycol->ViscValues); + + // This is a speed optimization. Maybe. + glycol->CpTempRatios.allocate(glycol->NumCpTempPoints); + for (int i = 1; i < glycol->NumCpTempPoints; ++i) + glycol->CpTempRatios(i) = (glycol->CpValues(i+1) - glycol->CpValues(i)) / (glycol->CpTemps(i+1) - glycol->CpTemps(i)); + glycol->RhoTempRatios.allocate(glycol->NumRhoTempPoints); + for (int i = 1; i < glycol->NumRhoTempPoints; ++i) + glycol->RhoTempRatios(i) = (glycol->RhoValues(i+1) - glycol->RhoValues(i)) / (glycol->RhoTemps(i+1) - glycol->RhoTemps(i)); + glycol->CondTempRatios.allocate(glycol->NumCondTempPoints); + for (int i = 1; i < glycol->NumCondTempPoints; ++i) + glycol->CondTempRatios(i) = (glycol->CondValues(i+1) - glycol->CondValues(i)) / (glycol->CondTemps(i+1) - glycol->CondTemps(i)); + glycol->ViscTempRatios.allocate(glycol->NumViscTempPoints); + for (int i = 1; i < glycol->NumCondTempPoints; ++i) + glycol->ViscTempRatios(i) = (glycol->ViscValues(i+1) - glycol->ViscValues(i)) / (glycol->ViscTemps(i+1) - glycol->ViscTemps(i)); + } // for (Loop) + if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols if (!ErrorsFound) InitializeRefrigerantLimits(state, ErrorsFound); // Initialize the limits for the refrigerants @@ -2518,14 +1707,14 @@ namespace FluidProperties { FluidTemps.deallocate(); Alphas.deallocate(); - cAlphaFieldNames.deallocate(); + cAlphaFields.deallocate(); lAlphaFieldBlanks.deallocate(); Numbers.deallocate(); - cNumericFieldNames.deallocate(); + cNumericFields.deallocate(); lNumericFieldBlanks.deallocate(); if (ErrorsFound) { - ShowFatalError(state, format("{}Previous errors in input cause program termination.", RoutineName)); + ShowFatalError(state, format("{}: Previous errors in input cause program termination.", routineName)); } if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) df->DebugReportGlycols = true; @@ -2542,87 +1731,6 @@ namespace FluidProperties { //***************************************************************************** - template - void InterpDefValuesForGlycolConc( - EnergyPlusData &state, - const std::array &RawConcData, // concentrations for raw data - const std::array, NumOfConcs> &RawPropData, // raw property data (concentration, temperature) - Real64 Concentration, // concentration of actual fluid mix - Array1D &InterpData // interpolated output data at proper concentration - ) - { - - // SUBROUTINE INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - - // PURPOSE OF THIS SUBROUTINE: - // The purpose of this subroutine is to find the values for the property - // data at a particular concentration from default data that is at "generic" - // concentrations. This is then returned to the main get routine and - // then used later in the program to find values at various temperatures. - // The ultimate purpose of this is to avoid double interpolation during - // the simulation. Since concentration does not change during the simulation, - // there is no reason to do a double interpolation every time a property - // value is needed. - - // METHODOLOGY EMPLOYED: - // Fairly straight forward--find the two concentrations between which - // the actual concentration falls and then interpolate the property - // data using standard linear interpolation. Note that data is stored - // in the format: std::array[Concentration][Temperature] - - // SUBROUTINE PARAMETER DEFINITIONS: - constexpr Real64 ConcToler(0.0001); // Some reasonable value for comparisons - static constexpr std::string_view RoutineName("InterpDefValuesForGlycolConc: "); - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - size_t HiIndex; // index on the high side of the concentration - Real64 InterpFrac; // intermediate value for interpolations - size_t LoopC; // loop counter for concentration - size_t LoopT; // loop counter for temperature - - // First, find where the actual concentration falls between the concentration data. - // Then, interpolate if necessary. - if (Concentration < RawConcData[0]) { // Concentration too low - ShowWarningError(state, - format("{}Glycol concentration out of range for data (too low), concentration = {:.3R}", RoutineName, Concentration)); - ShowContinueError(state, "Check your data or the definition of your glycols in the GlycolConcentrations input"); - ShowContinueError(state, "Property data set to data for lowest concentration entered"); - InterpData = RawPropData[0][0]; - } else if (Concentration > RawConcData[NumOfConcs - 1]) { // Concentration too high - ShowWarningError(state, - format("{}Glycol concentration out of range for data (too high), concentration = {:.3R}", RoutineName, Concentration)); - ShowContinueError(state, "Check your data or the definition of your glycols in the GlycolConcentrations input"); - ShowContinueError(state, "Property data set to data for highest concentration entered"); - InterpData = RawPropData[NumOfConcs - 1][0]; - } else { // Concentration somewhere between lowest and highest point--interpolate - HiIndex = NumOfConcs - 1; // Default to highest concentration - 1, since std::arrays start at 0 - for (LoopC = 1; LoopC < NumOfConcs - 1; ++LoopC) { - if (Concentration <= RawConcData[LoopC]) { - HiIndex = LoopC; - break; // LoopC DO loop - } - } - if (std::abs(RawConcData[HiIndex] - RawConcData[HiIndex - 1]) >= ConcToler) { - InterpFrac = (RawConcData[HiIndex] - Concentration) / (RawConcData[HiIndex] - RawConcData[HiIndex - 1]); - for (LoopT = 0; LoopT < NumOfTemps; ++LoopT) { - if ((RawPropData[HiIndex][LoopT] < ConcToler) || (RawPropData[HiIndex - 1][LoopT] < ConcToler)) { - // One of the two values is zero--so we cannot interpolate for this point (assign to zero) - InterpData(LoopT + 1) = 0.0; - } else { - InterpData(LoopT + 1) = - RawPropData[HiIndex][LoopT] - (InterpFrac * (RawPropData[HiIndex][LoopT] - RawPropData[HiIndex - 1][LoopT])); - } - } - } else { // user has input data for concentrations that are too close or repeated, this must be fixed - ShowFatalError(state, format("{}concentration values too close or data repeated, check your fluid property input data", RoutineName)); - } - } - } - - //***************************************************************************** - void InterpValuesForGlycolConc(EnergyPlusData &state, int const NumOfConcs, // number of concentrations (dimension of raw data) int const NumOfTemps, // number of temperatures (dimension of raw data) @@ -2662,7 +1770,7 @@ namespace FluidProperties { // SUBROUTINE PARAMETER DEFINITIONS: constexpr Real64 ConcToler(0.0001); // Some reasonable value for comparisons - static constexpr std::string_view RoutineName("InterpValuesForGlycolConc: "); + static constexpr std::string_view routineName = "InterpValuesForGlycolConc"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int HiIndex; // index on the high side of the concentration @@ -2674,13 +1782,13 @@ namespace FluidProperties { // Then, interpolate if necessary. if (Concentration < RawConcData(1)) { // Concentration too low ShowWarningError(state, - format("{}Glycol concentration out of range for data (too low), concentration = {:.3R}", RoutineName, Concentration)); + format("{}: Glycol concentration out of range for data (too low), concentration = {:.3R}", routineName, Concentration)); ShowContinueError(state, "Check your data or the definition of your glycols in the GlycolConcentrations input"); ShowContinueError(state, "Property data set to data for lowest concentration entered"); InterpData = RawPropData(1, _); } else if (Concentration > RawConcData(NumOfConcs)) { // Concentration too high ShowWarningError(state, - format("{}Glycol concentration out of range for data (too high), concentration = {:.3R}", RoutineName, Concentration)); + format("{}: Glycol concentration out of range for data (too high), concentration = {:.3R}", routineName, Concentration)); ShowContinueError(state, "Check your data or the definition of your glycols in the GlycolConcentrations input"); ShowContinueError(state, "Property data set to data for highest concentration entered"); InterpData = RawPropData(NumOfConcs, _); @@ -2708,7 +1816,7 @@ namespace FluidProperties { } } } else { // user has input data for concentrations that are too close or repeated, this must be fixed - ShowFatalError(state, format("{}concentration values too close or data repeated, check your fluid property input data", RoutineName)); + ShowFatalError(state, format("{}: concentration values too close or data repeated, check your fluid property input data", routineName)); } } } @@ -2729,89 +1837,88 @@ namespace FluidProperties { auto &df = state.dataFluidProps; - for (int GlycolNum = 1; GlycolNum <= df->NumOfGlycols; ++GlycolNum) { - auto &glycol = df->GlycolData(GlycolNum); - if (glycol.CpDataPresent) { + for (auto *glycol : df->glycols) { + if (glycol->CpDataPresent) { // check for lowest non-zero value by referencing temp data - for (int IndexNum = 1; IndexNum <= glycol.NumCpTempPts; ++IndexNum) { - if (glycol.CpValues(IndexNum) <= 0.0) continue; - glycol.CpLowTempIndex = IndexNum; - glycol.CpLowTempValue = glycol.CpTemps(IndexNum); + for (int IndexNum = 1; IndexNum <= glycol->NumCpTempPoints; ++IndexNum) { + if (glycol->CpValues(IndexNum) <= 0.0) continue; + glycol->CpLowTempIndex = IndexNum; + glycol->CpLowTempValue = glycol->CpTemps(IndexNum); break; } // check for highest non-zero value by referencing temp data - for (int IndexNum = glycol.NumCpTempPts; IndexNum >= 1; --IndexNum) { - if (glycol.CpValues(IndexNum) <= 0.0) continue; - glycol.CpHighTempIndex = IndexNum; - glycol.CpHighTempValue = glycol.CpTemps(IndexNum); + for (int IndexNum = glycol->NumCpTempPoints; IndexNum >= 1; --IndexNum) { + if (glycol->CpValues(IndexNum) <= 0.0) continue; + glycol->CpHighTempIndex = IndexNum; + glycol->CpHighTempValue = glycol->CpTemps(IndexNum); break; } } - if (glycol.RhoDataPresent) { + if (glycol->RhoDataPresent) { // check for lowest non-zero value by referencing temp data - for (int IndexNum = 1; IndexNum <= glycol.NumRhoTempPts; ++IndexNum) { - if (glycol.RhoValues(IndexNum) <= 0.0) continue; - glycol.RhoLowTempIndex = IndexNum; - glycol.RhoLowTempValue = glycol.RhoTemps(IndexNum); + for (int IndexNum = 1; IndexNum <= glycol->NumRhoTempPoints; ++IndexNum) { + if (glycol->RhoValues(IndexNum) <= 0.0) continue; + glycol->RhoLowTempIndex = IndexNum; + glycol->RhoLowTempValue = glycol->RhoTemps(IndexNum); break; } // check for highest non-zero value by referencing temp data - for (int IndexNum = glycol.NumRhoTempPts; IndexNum >= 1; --IndexNum) { - if (glycol.RhoValues(IndexNum) <= 0.0) continue; - glycol.RhoHighTempIndex = IndexNum; - glycol.RhoHighTempValue = glycol.RhoTemps(IndexNum); + for (int IndexNum = glycol->NumRhoTempPoints; IndexNum >= 1; --IndexNum) { + if (glycol->RhoValues(IndexNum) <= 0.0) continue; + glycol->RhoHighTempIndex = IndexNum; + glycol->RhoHighTempValue = glycol->RhoTemps(IndexNum); break; } } - if (glycol.CondDataPresent) { + if (glycol->CondDataPresent) { // check for lowest non-zero value by referencing temp data - for (int IndexNum = 1; IndexNum <= glycol.NumCondTempPts; ++IndexNum) { - if (glycol.CondValues(IndexNum) <= 0.0) continue; - glycol.CondLowTempIndex = IndexNum; - glycol.CondLowTempValue = glycol.CondTemps(IndexNum); + for (int IndexNum = 1; IndexNum <= glycol->NumCondTempPoints; ++IndexNum) { + if (glycol->CondValues(IndexNum) <= 0.0) continue; + glycol->CondLowTempIndex = IndexNum; + glycol->CondLowTempValue = glycol->CondTemps(IndexNum); break; } // check for highest non-zero value by referencing temp data - for (int IndexNum = glycol.NumCondTempPts; IndexNum >= 1; --IndexNum) { - if (glycol.CondValues(IndexNum) <= 0.0) continue; - glycol.CondHighTempIndex = IndexNum; - glycol.CondHighTempValue = glycol.CondTemps(IndexNum); + for (int IndexNum = glycol->NumCondTempPoints; IndexNum >= 1; --IndexNum) { + if (glycol->CondValues(IndexNum) <= 0.0) continue; + glycol->CondHighTempIndex = IndexNum; + glycol->CondHighTempValue = glycol->CondTemps(IndexNum); break; } } - if (glycol.ViscDataPresent) { + if (glycol->ViscDataPresent) { // check for lowest non-zero value by referencing temp data - for (int IndexNum = 1; IndexNum <= glycol.NumViscTempPts; ++IndexNum) { - if (glycol.ViscValues(IndexNum) <= 0.0) continue; - glycol.ViscLowTempIndex = IndexNum; - glycol.ViscLowTempValue = glycol.ViscTemps(IndexNum); + for (int IndexNum = 1; IndexNum <= glycol->NumViscTempPoints; ++IndexNum) { + if (glycol->ViscValues(IndexNum) <= 0.0) continue; + glycol->ViscLowTempIndex = IndexNum; + glycol->ViscLowTempValue = glycol->ViscTemps(IndexNum); break; } // check for highest non-zero value by referencing temp data - for (int IndexNum = glycol.NumViscTempPts; IndexNum >= 1; --IndexNum) { - if (glycol.ViscValues(IndexNum) <= 0.0) continue; - glycol.ViscHighTempIndex = IndexNum; - glycol.ViscHighTempValue = glycol.ViscTemps(IndexNum); + for (int IndexNum = glycol->NumViscTempPoints; IndexNum >= 1; --IndexNum) { + if (glycol->ViscValues(IndexNum) <= 0.0) continue; + glycol->ViscHighTempIndex = IndexNum; + glycol->ViscHighTempValue = glycol->ViscTemps(IndexNum); break; } } bool Failure = false; // Check to see that all are set to non-zero - if (glycol.CpDataPresent) { - Failure = glycol.CpLowTempIndex == 0 || glycol.CpHighTempIndex == 0; + if (glycol->CpDataPresent) { + Failure = glycol->CpLowTempIndex == 0 || glycol->CpHighTempIndex == 0; } - if (glycol.RhoDataPresent) { - Failure = glycol.RhoLowTempIndex == 0 || glycol.RhoHighTempIndex == 0; + if (glycol->RhoDataPresent) { + Failure = glycol->RhoLowTempIndex == 0 || glycol->RhoHighTempIndex == 0; } - if (glycol.CondDataPresent) { - Failure = glycol.CondLowTempIndex == 0 || glycol.CondHighTempIndex == 0; + if (glycol->CondDataPresent) { + Failure = glycol->CondLowTempIndex == 0 || glycol->CondHighTempIndex == 0; } - if (glycol.ViscDataPresent) { - Failure = glycol.ViscLowTempIndex == 0 || glycol.ViscHighTempIndex == 0; + if (glycol->ViscDataPresent) { + Failure = glycol->ViscLowTempIndex == 0 || glycol->ViscHighTempIndex == 0; } if (Failure) { ShowSevereError(state, - format("InitializeGlycolTempLimits: Required values for Glycol={} are all zeroes for some data types.", glycol.Name)); + format("InitializeGlycolTempLimits: Required values for Glycol={} are all zeroes for some data types.", glycol->Name)); ErrorsFound = true; } } @@ -2833,116 +1940,115 @@ namespace FluidProperties { // be set up for symmetry and not be limited to just valid values. auto &df = state.dataFluidProps; - for (int RefrigNum = 1; RefrigNum <= df->NumOfRefrigerants; ++RefrigNum) { - auto &refrig = df->RefrigData(RefrigNum); - for (int IndexNum = 1; IndexNum <= refrig.NumPsPoints; ++IndexNum) { - if (refrig.PsValues(IndexNum) <= 0.0) continue; - refrig.PsLowPresIndex = IndexNum; - refrig.PsLowPresValue = refrig.PsValues(IndexNum); - refrig.PsLowTempValue = refrig.PsTemps(IndexNum); - refrig.PsLowTempIndex = IndexNum; + for (auto *refrig : df->refrigs) { + for (int IndexNum = 1; IndexNum <= refrig->NumPsPoints; ++IndexNum) { + if (refrig->PsValues(IndexNum) <= 0.0) continue; + refrig->PsLowPresIndex = IndexNum; + refrig->PsLowPresValue = refrig->PsValues(IndexNum); + refrig->PsLowTempValue = refrig->PsTemps(IndexNum); + refrig->PsLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumPsPoints; IndexNum >= 1; --IndexNum) { - if (refrig.PsValues(IndexNum) <= 0.0) continue; - refrig.PsHighPresIndex = IndexNum; - refrig.PsHighPresValue = refrig.PsValues(IndexNum); - refrig.PsHighTempValue = refrig.PsTemps(IndexNum); - refrig.PsHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumPsPoints; IndexNum >= 1; --IndexNum) { + if (refrig->PsValues(IndexNum) <= 0.0) continue; + refrig->PsHighPresIndex = IndexNum; + refrig->PsHighPresValue = refrig->PsValues(IndexNum); + refrig->PsHighTempValue = refrig->PsTemps(IndexNum); + refrig->PsHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumHPoints; ++IndexNum) { - if (refrig.HfValues(IndexNum) <= 0.0) continue; - refrig.HfLowTempValue = refrig.HfValues(IndexNum); - refrig.HfLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumHPoints; ++IndexNum) { + if (refrig->HfValues(IndexNum) <= 0.0) continue; + refrig->HfLowTempValue = refrig->HfValues(IndexNum); + refrig->HfLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumHPoints; IndexNum >= 1; --IndexNum) { - if (refrig.HfValues(IndexNum) <= 0.0) continue; - refrig.HfHighTempValue = refrig.HfValues(IndexNum); - refrig.HfHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumHPoints; IndexNum >= 1; --IndexNum) { + if (refrig->HfValues(IndexNum) <= 0.0) continue; + refrig->HfHighTempValue = refrig->HfValues(IndexNum); + refrig->HfHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumHPoints; ++IndexNum) { - if (refrig.HfgValues(IndexNum) <= 0.0) continue; - refrig.HfgLowTempValue = refrig.HfgValues(IndexNum); - refrig.HfgLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumHPoints; ++IndexNum) { + if (refrig->HfgValues(IndexNum) <= 0.0) continue; + refrig->HfgLowTempValue = refrig->HfgValues(IndexNum); + refrig->HfgLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumHPoints; IndexNum >= 1; --IndexNum) { - if (refrig.HfgValues(IndexNum) <= 0.0) continue; - refrig.HfgHighTempValue = refrig.HfgValues(IndexNum); - refrig.HfgHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumHPoints; IndexNum >= 1; --IndexNum) { + if (refrig->HfgValues(IndexNum) <= 0.0) continue; + refrig->HfgHighTempValue = refrig->HfgValues(IndexNum); + refrig->HfgHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumCpPoints; ++IndexNum) { - if (refrig.CpfValues(IndexNum) <= 0.0) continue; - refrig.CpfLowTempValue = refrig.CpfValues(IndexNum); - refrig.CpfLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumCpPoints; ++IndexNum) { + if (refrig->CpfValues(IndexNum) <= 0.0) continue; + refrig->CpfLowTempValue = refrig->CpfValues(IndexNum); + refrig->CpfLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumCpPoints; IndexNum >= 1; --IndexNum) { - if (refrig.CpfValues(IndexNum) <= 0.0) continue; - refrig.CpfHighTempValue = refrig.CpfValues(IndexNum); - refrig.CpfHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumCpPoints; IndexNum >= 1; --IndexNum) { + if (refrig->CpfValues(IndexNum) <= 0.0) continue; + refrig->CpfHighTempValue = refrig->CpfValues(IndexNum); + refrig->CpfHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumCpPoints; ++IndexNum) { - if (refrig.CpfgValues(IndexNum) <= 0.0) continue; - refrig.CpfgLowTempValue = refrig.CpfgValues(IndexNum); - refrig.CpfgLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumCpPoints; ++IndexNum) { + if (refrig->CpfgValues(IndexNum) <= 0.0) continue; + refrig->CpfgLowTempValue = refrig->CpfgValues(IndexNum); + refrig->CpfgLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumCpPoints; IndexNum >= 1; --IndexNum) { - if (refrig.CpfgValues(IndexNum) <= 0.0) continue; - refrig.CpfgHighTempValue = refrig.CpfgValues(IndexNum); - refrig.CpfgHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumCpPoints; IndexNum >= 1; --IndexNum) { + if (refrig->CpfgValues(IndexNum) <= 0.0) continue; + refrig->CpfgHighTempValue = refrig->CpfgValues(IndexNum); + refrig->CpfgHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumRhoPoints; ++IndexNum) { - if (refrig.RhofValues(IndexNum) <= 0.0) continue; - refrig.RhofLowTempValue = refrig.RhofValues(IndexNum); - refrig.RhofLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumRhoPoints; ++IndexNum) { + if (refrig->RhofValues(IndexNum) <= 0.0) continue; + refrig->RhofLowTempValue = refrig->RhofValues(IndexNum); + refrig->RhofLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumRhoPoints; IndexNum >= 1; --IndexNum) { - if (refrig.RhofValues(IndexNum) <= 0.0) continue; - refrig.RhofHighTempValue = refrig.RhofValues(IndexNum); - refrig.RhofHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumRhoPoints; IndexNum >= 1; --IndexNum) { + if (refrig->RhofValues(IndexNum) <= 0.0) continue; + refrig->RhofHighTempValue = refrig->RhofValues(IndexNum); + refrig->RhofHighTempIndex = IndexNum; break; } - for (int IndexNum = 1; IndexNum <= refrig.NumRhoPoints; ++IndexNum) { - if (refrig.RhofgValues(IndexNum) <= 0.0) continue; - refrig.RhofgLowTempValue = refrig.RhofgValues(IndexNum); - refrig.RhofgLowTempIndex = IndexNum; + for (int IndexNum = 1; IndexNum <= refrig->NumRhoPoints; ++IndexNum) { + if (refrig->RhofgValues(IndexNum) <= 0.0) continue; + refrig->RhofgLowTempValue = refrig->RhofgValues(IndexNum); + refrig->RhofgLowTempIndex = IndexNum; break; } - for (int IndexNum = refrig.NumRhoPoints; IndexNum >= 1; --IndexNum) { - if (refrig.RhofgValues(IndexNum) <= 0.0) continue; - refrig.RhofgHighTempValue = refrig.RhofgValues(IndexNum); - refrig.RhofgHighTempIndex = IndexNum; + for (int IndexNum = refrig->NumRhoPoints; IndexNum >= 1; --IndexNum) { + if (refrig->RhofgValues(IndexNum) <= 0.0) continue; + refrig->RhofgHighTempValue = refrig->RhofgValues(IndexNum); + refrig->RhofgHighTempIndex = IndexNum; break; } bool Failure = false; // Check to see that all are set to non-zero - if (refrig.NumPsPoints > 0) { - Failure = refrig.PsLowPresIndex == 0 || refrig.PsLowTempIndex == 0 || refrig.PsHighPresIndex == 0 || refrig.PsHighTempIndex == 0; + if (refrig->NumPsPoints > 0) { + Failure = refrig->PsLowPresIndex == 0 || refrig->PsLowTempIndex == 0 || refrig->PsHighPresIndex == 0 || refrig->PsHighTempIndex == 0; } - if (refrig.NumHPoints > 0) { - Failure = refrig.HfLowTempIndex == 0 || refrig.HfgLowTempIndex == 0 || refrig.HfHighTempIndex == 0 || refrig.HfgHighTempIndex == 0; + if (refrig->NumHPoints > 0) { + Failure = refrig->HfLowTempIndex == 0 || refrig->HfgLowTempIndex == 0 || refrig->HfHighTempIndex == 0 || refrig->HfgHighTempIndex == 0; } - if (refrig.NumCpPoints > 0) { + if (refrig->NumCpPoints > 0) { Failure = - refrig.CpfLowTempIndex == 0 || refrig.CpfgLowTempIndex == 0 || refrig.CpfHighTempIndex == 0 || refrig.CpfgHighTempIndex == 0; + refrig->CpfLowTempIndex == 0 || refrig->CpfgLowTempIndex == 0 || refrig->CpfHighTempIndex == 0 || refrig->CpfgHighTempIndex == 0; } - if (refrig.NumRhoPoints > 0) { + if (refrig->NumRhoPoints > 0) { Failure = - refrig.RhofLowTempIndex == 0 || refrig.RhofgLowTempIndex == 0 || refrig.RhofHighTempIndex == 0 || refrig.RhofgHighTempIndex == 0; + refrig->RhofLowTempIndex == 0 || refrig->RhofgLowTempIndex == 0 || refrig->RhofHighTempIndex == 0 || refrig->RhofgHighTempIndex == 0; } if (Failure) { ShowSevereError( state, - format("InitializeRefrigerantLimits: Required values for Refrigerant={} are all zeroes for some data types.", refrig.Name)); + format("InitializeRefrigerantLimits: Required values for Refrigerant={} are all zeroes for some data types.", refrig->Name)); ErrorsFound = true; } } @@ -2967,7 +2073,7 @@ namespace FluidProperties { // SUBROUTINE PARAMETER DEFINITIONS: constexpr Real64 incr(10.0); - static constexpr std::string_view RoutineName("ReportAndTestGlycols"); + static constexpr std::string_view routineName = "ReportAndTestGlycols"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 Temperature; // Temperature to drive values @@ -2975,216 +2081,215 @@ namespace FluidProperties { auto &df = state.dataFluidProps; - for (int GlycolNum = 1; GlycolNum <= df->NumOfGlycols; ++GlycolNum) { - auto &glycol = df->GlycolData(GlycolNum); + for (auto *glycol : df->glycols) { int GlycolIndex = 0; // used in routine calls -- value is returned when first 0 // Lay out the basic values: - if (!glycol.GlycolName.empty()) { - print(state.files.debug, "Glycol={}, Mixture fluid={}\n", glycol.Name, glycol.GlycolName); + if (!glycol->GlycolName.empty()) { + print(state.files.debug, "Glycol={}, Mixture fluid={}\n", glycol->Name, glycol->GlycolName); } else { - print(state.files.debug, "Glycol={}\n", glycol.Name); + print(state.files.debug, "Glycol={}\n", glycol->Name); } - print(state.files.debug, "Concentration:,{:.2R}\n", glycol.Concentration); - if (glycol.CpDataPresent) { + print(state.files.debug, "Concentration:,{:.2R}\n", glycol->Concentration); + if (glycol->CpDataPresent) { print(state.files.debug, "Specific Heat Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - glycol.CpLowTempValue, - glycol.CpLowTempIndex, - glycol.CpHighTempValue, - glycol.CpHighTempIndex); + glycol->CpLowTempValue, + glycol->CpLowTempIndex, + glycol->CpHighTempValue, + glycol->CpHighTempIndex); print(state.files.debug, "{}", "Temperatures:"); - for (int Loop = 1; Loop <= glycol.NumCpTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CpTemps(Loop)); + for (int Loop = 1; Loop <= glycol->NumCpTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CpTemps(Loop)); } - print(state.files.debug, ",{}\n", glycol.CpTemps(glycol.NumCpTempPts)); + print(state.files.debug, ",{}\n", glycol->CpTemps(glycol->NumCpTempPoints)); print(state.files.debug, "{}", "Specific Heat:"); - for (int Loop = 1; Loop <= glycol.NumCpTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CpValues(Loop)); + for (int Loop = 1; Loop <= glycol->NumCpTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CpValues(Loop)); } - print(state.files.debug, ",{}\n", glycol.CpValues(glycol.NumCpTempPts)); + print(state.files.debug, ",{}\n", glycol->CpValues(glycol->NumCpTempPoints)); } - if (glycol.RhoDataPresent) { + if (glycol->RhoDataPresent) { print(state.files.debug, "Density Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - glycol.RhoLowTempValue, - glycol.RhoLowTempIndex, - glycol.RhoHighTempValue, - glycol.RhoHighTempIndex); + glycol->RhoLowTempValue, + glycol->RhoLowTempIndex, + glycol->RhoHighTempValue, + glycol->RhoHighTempIndex); print(state.files.debug, "{}", "Temperatures:"); - for (int Loop = 1; Loop <= glycol.NumRhoTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.RhoTemps(Loop)); + for (int Loop = 1; Loop <= glycol->NumRhoTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->RhoTemps(Loop)); } - print(state.files.debug, ",{}\n", glycol.RhoTemps(glycol.NumRhoTempPts)); + print(state.files.debug, ",{}\n", glycol->RhoTemps(glycol->NumRhoTempPoints)); print(state.files.debug, "{}", "Density:"); - for (int Loop = 1; Loop <= glycol.NumRhoTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.RhoValues(Loop)); + for (int Loop = 1; Loop <= glycol->NumRhoTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->RhoValues(Loop)); } - print(state.files.debug, ",{}\n", glycol.RhoTemps(glycol.NumRhoTempPts)); + print(state.files.debug, ",{}\n", glycol->RhoTemps(glycol->NumRhoTempPoints)); } - if (glycol.CondDataPresent) { + if (glycol->CondDataPresent) { print(state.files.debug, "Conductivity Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - glycol.CondLowTempValue, - glycol.CondLowTempIndex, - glycol.CondHighTempValue, - glycol.CondHighTempIndex); + glycol->CondLowTempValue, + glycol->CondLowTempIndex, + glycol->CondHighTempValue, + glycol->CondHighTempIndex); print(state.files.debug, "{}", "Temperatures:"); - for (int Loop = 1; Loop <= glycol.NumCondTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CondTemps(Loop)); + for (int Loop = 1; Loop <= glycol->NumCondTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CondTemps(Loop)); } - print(state.files.debug, ",{}\n", glycol.CondTemps(glycol.NumCondTempPts)); + print(state.files.debug, ",{}\n", glycol->CondTemps(glycol->NumCondTempPoints)); print(state.files.debug, "{}", "Conductivity:"); - for (int Loop = 1; Loop <= glycol.NumCondTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CondValues(Loop)); + for (int Loop = 1; Loop <= glycol->NumCondTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CondValues(Loop)); } - print(state.files.debug, ",{}\n", glycol.CondValues(glycol.NumCondTempPts)); + print(state.files.debug, ",{}\n", glycol->CondValues(glycol->NumCondTempPoints)); } - if (glycol.ViscDataPresent) { + if (glycol->ViscDataPresent) { print(state.files.debug, "Viscosity Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - glycol.ViscLowTempValue, - glycol.ViscLowTempIndex, - glycol.ViscHighTempValue, - glycol.ViscHighTempIndex); + glycol->ViscLowTempValue, + glycol->ViscLowTempIndex, + glycol->ViscHighTempValue, + glycol->ViscHighTempIndex); print(state.files.debug, "{}", "Temperatures:"); - for (int Loop = 1; Loop <= glycol.NumViscTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.ViscTemps(Loop)); + for (int Loop = 1; Loop <= glycol->NumViscTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->ViscTemps(Loop)); } - print(state.files.debug, ",{}\n", glycol.ViscTemps(glycol.NumViscTempPts)); + print(state.files.debug, ",{}\n", glycol->ViscTemps(glycol->NumViscTempPoints)); print(state.files.debug, "{}", "Viscosity:"); - for (int Loop = 1; Loop <= glycol.NumViscTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.ViscValues(Loop)); + for (int Loop = 1; Loop <= glycol->NumViscTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->ViscValues(Loop)); } - print(state.files.debug, ",{}\n", glycol.ViscValues(glycol.NumViscTempPts)); + print(state.files.debug, ",{}\n", glycol->ViscValues(glycol->NumViscTempPoints)); } // ============================================ // Glycol Results, using out of bounds to out of bounds values in calling // ============================================ // ========= Specific Heat from Temperatures - print(state.files.debug, "Glycol={} **** Results ****\n", glycol.Name); - if (glycol.CpDataPresent) { + print(state.files.debug, "Glycol={} **** Results ****\n", glycol->Name); + if (glycol->CpDataPresent) { print(state.files.debug, "Specific Heat Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", glycol.CpTemps(1) - incr); + print(state.files.debug, ",{:.2R}", glycol->CpTemps(1) - incr); - for (int Loop = 1; Loop <= glycol.NumCpTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CpTemps(Loop)); - Temperature = glycol.CpTemps(Loop) + (glycol.CpTemps(Loop + 1) - glycol.CpTemps(Loop)) / 2.0; + for (int Loop = 1; Loop <= glycol->NumCpTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CpTemps(Loop)); + Temperature = glycol->CpTemps(Loop) + (glycol->CpTemps(Loop + 1) - glycol->CpTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", glycol.CpTemps(glycol.NumCpTempPts)); - print(state.files.debug, ",{:.2R}\n", glycol.CpTemps(glycol.NumCpTempPts) + incr); + print(state.files.debug, ",{:.2R}", glycol->CpTemps(glycol->NumCpTempPoints)); + print(state.files.debug, ",{:.2R}\n", glycol->CpTemps(glycol->NumCpTempPoints) + incr); print(state.files.debug, "Specific Heat:"); - Temperature = glycol.CpTemps(1) - incr; - ReturnValue = GetSpecificHeatGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + Temperature = glycol->CpTemps(1) - incr; + ReturnValue = GetSpecificHeatGlycol(state, glycol->Name, Temperature, GlycolIndex, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= glycol.NumCpTempPts - 1; ++Loop) { - Temperature = glycol.CpTemps(Loop); - ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); + for (int Loop = 1; Loop <= glycol->NumCpTempPoints - 1; ++Loop) { + Temperature = glycol->CpTemps(Loop); + ReturnValue = glycol->getSpecificHeat(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = glycol.CpTemps(Loop) + (glycol.CpTemps(Loop + 1) - glycol.CpTemps(Loop)) / 2.0; - ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); + Temperature = glycol->CpTemps(Loop) + (glycol->CpTemps(Loop + 1) - glycol->CpTemps(Loop)) / 2.0; + ReturnValue = glycol->getSpecificHeat(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = glycol.CpTemps(glycol.NumCpTempPts); - ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); + Temperature = glycol->CpTemps(glycol->NumCpTempPoints); + ReturnValue = glycol->getSpecificHeat(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = glycol.CpTemps(glycol.NumCpTempPts) + incr; - ReturnValue = glycol.getSpecificHeat(state, Temperature, RoutineName); + Temperature = glycol->CpTemps(glycol->NumCpTempPoints) + incr; + ReturnValue = glycol->getSpecificHeat(state, Temperature, routineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Density from Temperatures - if (glycol.RhoDataPresent) { + if (glycol->RhoDataPresent) { print(state.files.debug, "Density Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", glycol.RhoTemps(1) - incr); - for (int Loop = 1; Loop <= glycol.NumRhoTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.RhoTemps(Loop)); - Temperature = glycol.RhoTemps(Loop) + (glycol.RhoTemps(Loop + 1) - glycol.RhoTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", glycol->RhoTemps(1) - incr); + for (int Loop = 1; Loop <= glycol->NumRhoTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->RhoTemps(Loop)); + Temperature = glycol->RhoTemps(Loop) + (glycol->RhoTemps(Loop + 1) - glycol->RhoTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{}", glycol.RhoTemps(glycol.NumRhoTempPts)); - print(state.files.debug, ",{:.2R}\n", glycol.RhoTemps(glycol.NumRhoTempPts) + incr); + print(state.files.debug, ",{}", glycol->RhoTemps(glycol->NumRhoTempPoints)); + print(state.files.debug, ",{:.2R}\n", glycol->RhoTemps(glycol->NumRhoTempPoints) + incr); print(state.files.debug, "Density:"); - Temperature = glycol.RhoTemps(1) - incr; - ReturnValue = GetDensityGlycol(state, glycol.Name, Temperature, GlycolIndex, RoutineName); + Temperature = glycol->RhoTemps(1) - incr; + ReturnValue = GetDensityGlycol(state, glycol->Name, Temperature, GlycolIndex, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - for (int Loop = 1; Loop <= glycol.NumRhoTempPts - 1; ++Loop) { - Temperature = glycol.RhoTemps(Loop); - ReturnValue = glycol.getDensity(state, Temperature, RoutineName); + for (int Loop = 1; Loop <= glycol->NumRhoTempPoints - 1; ++Loop) { + Temperature = glycol->RhoTemps(Loop); + ReturnValue = glycol->getDensity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - Temperature = glycol.RhoTemps(Loop) + (glycol.RhoTemps(Loop + 1) - glycol.RhoTemps(Loop)) / 2.0; - ReturnValue = glycol.getDensity(state, Temperature, RoutineName); + Temperature = glycol->RhoTemps(Loop) + (glycol->RhoTemps(Loop + 1) - glycol->RhoTemps(Loop)) / 2.0; + ReturnValue = glycol->getDensity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); } - Temperature = glycol.RhoTemps(glycol.NumRhoTempPts); - ReturnValue = glycol.getDensity(state, Temperature, RoutineName); + Temperature = glycol->RhoTemps(glycol->NumRhoTempPoints); + ReturnValue = glycol->getDensity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - Temperature = glycol.RhoTemps(glycol.NumRhoTempPts) + incr; - ReturnValue = glycol.getDensity(state, Temperature, RoutineName); + Temperature = glycol->RhoTemps(glycol->NumRhoTempPoints) + incr; + ReturnValue = glycol->getDensity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}\n", ReturnValue); } // ========= Conductivity from Temperatures - if (glycol.CondDataPresent) { + if (glycol->CondDataPresent) { print(state.files.debug, "Conductivity Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", glycol.CondTemps(1) - incr); - for (int Loop = 1; Loop <= glycol.NumCondTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.CondTemps(Loop)); - Temperature = glycol.CondTemps(Loop) + (glycol.CondTemps(Loop + 1) - glycol.CondTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", glycol->CondTemps(1) - incr); + for (int Loop = 1; Loop <= glycol->NumCondTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->CondTemps(Loop)); + Temperature = glycol->CondTemps(Loop) + (glycol->CondTemps(Loop + 1) - glycol->CondTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", glycol.CondTemps(glycol.NumCondTempPts)); - print(state.files.debug, ",{:.2R}\n", glycol.CondTemps(glycol.NumCondTempPts) + incr); + print(state.files.debug, ",{:.2R}", glycol->CondTemps(glycol->NumCondTempPoints)); + print(state.files.debug, ",{:.2R}\n", glycol->CondTemps(glycol->NumCondTempPoints) + incr); print(state.files.debug, "Conductivity:"); - Temperature = glycol.CondTemps(1) - incr; - ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); + Temperature = glycol->CondTemps(1) - incr; + ReturnValue = glycol->getConductivity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - for (int Loop = 1; Loop <= glycol.NumCondTempPts - 1; ++Loop) { - Temperature = glycol.CondTemps(Loop); - ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); + for (int Loop = 1; Loop <= glycol->NumCondTempPoints - 1; ++Loop) { + Temperature = glycol->CondTemps(Loop); + ReturnValue = glycol->getConductivity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - Temperature = glycol.CondTemps(Loop) + (glycol.CondTemps(Loop + 1) - glycol.CondTemps(Loop)) / 2.0; - ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); + Temperature = glycol->CondTemps(Loop) + (glycol->CondTemps(Loop + 1) - glycol->CondTemps(Loop)) / 2.0; + ReturnValue = glycol->getConductivity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); } - Temperature = glycol.CondTemps(glycol.NumCondTempPts); - ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); + Temperature = glycol->CondTemps(glycol->NumCondTempPoints); + ReturnValue = glycol->getConductivity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}", ReturnValue); - Temperature = glycol.CondTemps(glycol.NumCondTempPts) + incr; - ReturnValue = glycol.getConductivity(state, Temperature, RoutineName); + Temperature = glycol->CondTemps(glycol->NumCondTempPoints) + incr; + ReturnValue = glycol->getConductivity(state, Temperature, routineName); print(state.files.debug, ",{:.3R}\n", ReturnValue); } // ========= Viscosity from Temperatures - if (glycol.ViscDataPresent) { + if (glycol->ViscDataPresent) { print(state.files.debug, "Viscosity Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", glycol.ViscTemps(1) - incr); - for (int Loop = 1; Loop <= glycol.NumViscTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", glycol.ViscTemps(Loop)); - Temperature = glycol.ViscTemps(Loop) + (glycol.ViscTemps(Loop + 1) - glycol.ViscTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", glycol->ViscTemps(1) - incr); + for (int Loop = 1; Loop <= glycol->NumViscTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", glycol->ViscTemps(Loop)); + Temperature = glycol->ViscTemps(Loop) + (glycol->ViscTemps(Loop + 1) - glycol->ViscTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", glycol.ViscTemps(glycol.NumViscTempPts)); - print(state.files.debug, ",{:.2R}\n", glycol.ViscTemps(glycol.NumViscTempPts) + incr); + print(state.files.debug, ",{:.2R}", glycol->ViscTemps(glycol->NumViscTempPoints)); + print(state.files.debug, ",{:.2R}\n", glycol->ViscTemps(glycol->NumViscTempPoints) + incr); print(state.files.debug, "Viscosity:"); - Temperature = glycol.ViscTemps(1) - incr; - ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); + Temperature = glycol->ViscTemps(1) - incr; + ReturnValue = glycol->getViscosity(state, Temperature, routineName); print(state.files.debug, ",{:.4R}", ReturnValue); - for (int Loop = 1; Loop <= glycol.NumViscTempPts - 1; ++Loop) { - Temperature = glycol.ViscTemps(Loop); - ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); + for (int Loop = 1; Loop <= glycol->NumViscTempPoints - 1; ++Loop) { + Temperature = glycol->ViscTemps(Loop); + ReturnValue = glycol->getViscosity(state, Temperature, routineName); print(state.files.debug, ",{:.4R}", ReturnValue); - Temperature = glycol.ViscTemps(Loop) + (glycol.ViscTemps(Loop + 1) - glycol.ViscTemps(Loop)) / 2.0; - ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); + Temperature = glycol->ViscTemps(Loop) + (glycol->ViscTemps(Loop + 1) - glycol->ViscTemps(Loop)) / 2.0; + ReturnValue = glycol->getViscosity(state, Temperature, routineName); print(state.files.debug, ",{:.4R}", ReturnValue); } - Temperature = glycol.ViscTemps(glycol.NumViscTempPts); - ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); + Temperature = glycol->ViscTemps(glycol->NumViscTempPoints); + ReturnValue = glycol->getViscosity(state, Temperature, routineName); print(state.files.debug, ",{:.4R}", ReturnValue); - Temperature = glycol.ViscTemps(glycol.NumViscTempPts) + incr; - ReturnValue = glycol.getViscosity(state, Temperature, RoutineName); + Temperature = glycol->ViscTemps(glycol->NumViscTempPoints) + incr; + ReturnValue = glycol->getViscosity(state, Temperature, routineName); print(state.files.debug, ",{:.4R}\n", ReturnValue); } } @@ -3210,7 +2315,7 @@ namespace FluidProperties { // SUBROUTINE PARAMETER DEFINITIONS: constexpr Real64 incr(10.0); constexpr Real64 Quality(1.0); - static constexpr std::string_view RoutineName("ReportAndTestRefrigerants"); + static constexpr std::string_view routineName = "ReportAndTestRefrigerants"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 Temperature; // Temperature to drive values @@ -3218,179 +2323,178 @@ namespace FluidProperties { auto &df = state.dataFluidProps; - for (int RefrigNum = 1; RefrigNum <= df->NumOfRefrigerants; ++RefrigNum) { - auto &refrig = df->RefrigData(RefrigNum); + for (auto *refrig : df->refrigs) { // Lay out the basic values: - if (!refrig.Name.empty()) { - print(state.files.debug, "Refrigerant={}", refrig.Name); + if (!refrig->Name.empty()) { + print(state.files.debug, "Refrigerant={}", refrig->Name); } - if (refrig.NumPsPoints > 0) { + if (refrig->NumPsPoints > 0) { print(state.files.debug, "Saturation Pressures Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.PsLowTempValue, - refrig.PsLowTempIndex, - refrig.PsHighTempValue, - refrig.PsHighTempIndex); + refrig->PsLowTempValue, + refrig->PsLowTempIndex, + refrig->PsHighTempValue, + refrig->PsHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.PsTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->PsTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.PsTemps(refrig.NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->PsTemps(refrig->NumPsPoints)); print(state.files.debug, "Saturation Pressure:"); - for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.PsValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->PsValues(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.PsValues(refrig.NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->PsValues(refrig->NumPsPoints)); } - if (refrig.NumHPoints > 0) { + if (refrig->NumHPoints > 0) { print(state.files.debug, "Enthalpy Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.HfLowTempValue, - refrig.HfLowTempIndex, - refrig.HfHighTempValue, - refrig.HfHighTempIndex); + refrig->HfLowTempValue, + refrig->HfLowTempIndex, + refrig->HfHighTempValue, + refrig->HfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->HTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->HTemps(refrig->NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid:"); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.HfValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->HfValues(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.HfValues(refrig.NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->HfValues(refrig->NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.HfgLowTempValue, - refrig.HfgLowTempIndex, - refrig.HfgHighTempValue, - refrig.HfgHighTempIndex); + refrig->HfgLowTempValue, + refrig->HfgLowTempIndex, + refrig->HfgHighTempValue, + refrig->HfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->HTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->HTemps(refrig->NumHPoints)); print(state.files.debug, "Enthalpy Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.HfgValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->HfgValues(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.HfgValues(refrig.NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->HfgValues(refrig->NumHPoints)); } - if (refrig.NumCpPoints > 0) { + if (refrig->NumCpPoints > 0) { print(state.files.debug, "Specific Heat Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.CpfLowTempValue, - refrig.CpfLowTempIndex, - refrig.CpfHighTempValue, - refrig.CpfHighTempIndex); + refrig->CpfLowTempValue, + refrig->CpfLowTempIndex, + refrig->CpfHighTempValue, + refrig->CpfHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->CpTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->CpTemps(refrig->NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid:"); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}\n", refrig.CpfValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}\n", refrig->CpfValues(Loop)); } - print(state.files.debug, ",{:.2R}", refrig.CpfValues(refrig.NumCpPoints)); + print(state.files.debug, ",{:.2R}", refrig->CpfValues(refrig->NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.CpfgLowTempValue, - refrig.CpfgLowTempIndex, - refrig.CpfgHighTempValue, - refrig.CpfgHighTempIndex); + refrig->CpfgLowTempValue, + refrig->CpfgLowTempIndex, + refrig->CpfgHighTempValue, + refrig->CpfgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->CpTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->CpTemps(refrig->NumCpPoints)); print(state.files.debug, "Specific Heat Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.CpfgValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->CpfgValues(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.CpfgValues(refrig.NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->CpfgValues(refrig->NumCpPoints)); } - if (refrig.NumRhoPoints > 0) { + if (refrig->NumRhoPoints > 0) { print(state.files.debug, "Density Saturated Fluid Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.RhofLowTempValue, - refrig.RhofLowTempIndex, - refrig.RhofHighTempValue, - refrig.RhofHighTempIndex); + refrig->RhofLowTempValue, + refrig->RhofLowTempIndex, + refrig->RhofHighTempValue, + refrig->RhofHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(Loop)); } - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(refrig.NumRhoPoints)); + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(refrig->NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid:"); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.RhofValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->RhofValues(Loop)); } - print(state.files.debug, ",{:.2R}", refrig.RhofValues(refrig.NumRhoPoints)); + print(state.files.debug, ",{:.2R}", refrig->RhofValues(refrig->NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas Data points:,Low Temperature=,{:.2R},Index=,{},High Temperature=,{:.2R},Index=,{}\n", - refrig.RhofgLowTempValue, - refrig.RhofgLowTempIndex, - refrig.RhofgHighTempValue, - refrig.RhofgHighTempIndex); + refrig->RhofgLowTempValue, + refrig->RhofgLowTempIndex, + refrig->RhofgHighTempValue, + refrig->RhofgHighTempIndex); print(state.files.debug, "Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.RhoTemps(refrig.NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->RhoTemps(refrig->NumRhoPoints)); print(state.files.debug, "Density Saturated Fluid/Gas:"); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.RhofgValues(Loop)); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->RhofgValues(Loop)); } - print(state.files.debug, ",{:.2R}\n", refrig.RhofgValues(refrig.NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->RhofgValues(refrig->NumRhoPoints)); } - if (refrig.NumSuperTempPts > 0 && refrig.NumSuperPressPts > 0) { + if (refrig->NumSupTempPoints > 0 && refrig->NumSupPressPoints > 0) { print(state.files.debug, "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", - refrig.NumSuperTempPts, - refrig.NumSuperPressPts); + refrig->NumSupTempPoints, + refrig->NumSupPressPoints); print(state.files.debug, "Superheated Temperatures:"); - for (int Loop = 1; Loop <= refrig.NumSuperTempPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", refrig.SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumSupTempPoints - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", refrig->SupTemps(Loop)); } - print(state.files.debug, ",{:.3R}\n", refrig.SHTemps(refrig.NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig->SupTemps(refrig->NumSupTempPoints)); print(state.files.debug, "Superheated Pressures:"); - for (int Loop = 1; Loop <= refrig.NumSuperPressPts - 1; ++Loop) { - print(state.files.debug, ",{:.3R}", refrig.SHPress(Loop)); + for (int Loop = 1; Loop <= refrig->NumSupPressPoints - 1; ++Loop) { + print(state.files.debug, ",{:.3R}", refrig->SupPress(Loop)); } - print(state.files.debug, ",{:.3R}\n", refrig.SHPress(refrig.NumSuperPressPts)); - for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig.SHPress(Loop)); + print(state.files.debug, ",{:.3R}\n", refrig->SupPress(refrig->NumSupPressPoints)); + for (int Loop = 1; Loop <= refrig->NumSupPressPoints; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig->SupPress(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= refrig.NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", refrig.HshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= refrig->NumSupTempPoints - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig->HshValues(Loop, Loop1)); } - print(state.files.debug, ",{:.3R}\n", refrig.HshValues(Loop, refrig.NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig->HshValues(Loop, refrig->NumSupTempPoints)); } - for (int Loop = 1; Loop <= refrig.NumSuperPressPts; ++Loop) { - print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig.SHPress(Loop)); + for (int Loop = 1; Loop <= refrig->NumSupPressPoints; ++Loop) { + print(state.files.debug, "Superheated Pressure:#{}={:.2R}\n", Loop, refrig->SupPress(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= refrig.NumSuperTempPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", refrig.RhoshValues(Loop, Loop1)); + for (int Loop1 = 1; Loop1 <= refrig->NumSupTempPoints - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig->RhoshValues(Loop, Loop1)); } - print(state.files.debug, ",{:.3R}\n", refrig.RhoshValues(Loop, refrig.NumSuperTempPts)); + print(state.files.debug, ",{:.3R}\n", refrig->RhoshValues(Loop, refrig->NumSupTempPoints)); } - for (int Loop = 1; Loop <= refrig.NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig.SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumSupTempPoints; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig->SupTemps(Loop)); print(state.files.debug, "Enthalpy Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= refrig.NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", refrig.HshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= refrig->NumSupPressPoints - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig->HshValues(Loop1, Loop)); } - print(state.files.debug, ",{:.3R}\n", refrig.HshValues(refrig.NumSuperPressPts, Loop)); + print(state.files.debug, ",{:.3R}\n", refrig->HshValues(refrig->NumSupPressPoints, Loop)); } - for (int Loop = 1; Loop <= refrig.NumSuperTempPts; ++Loop) { - print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig.SHTemps(Loop)); + for (int Loop = 1; Loop <= refrig->NumSupTempPoints; ++Loop) { + print(state.files.debug, "Superheated Temperature:#{}={:.2R}\n", Loop, refrig->SupTemps(Loop)); print(state.files.debug, "Density Superheated Gas:"); - for (int Loop1 = 1; Loop1 <= refrig.NumSuperPressPts - 1; ++Loop1) { - print(state.files.debug, ",{:.3R}", refrig.RhoshValues(Loop1, Loop)); + for (int Loop1 = 1; Loop1 <= refrig->NumSupPressPoints - 1; ++Loop1) { + print(state.files.debug, ",{:.3R}", refrig->RhoshValues(Loop1, Loop)); } - print(state.files.debug, ",{:.3R}\n", refrig.RhoshValues(refrig.NumSuperPressPts, Loop)); + print(state.files.debug, ",{:.3R}\n", refrig->RhoshValues(refrig->NumSupPressPoints, Loop)); } } @@ -3399,127 +2503,127 @@ namespace FluidProperties { // ============================================ // ========= Pressure from Temperatures - print(state.files.debug, "Refrigerant={} **** Results ****\n", refrig.Name); - if (refrig.NumPsPoints > 0) { + print(state.files.debug, "Refrigerant={} **** Results ****\n", refrig->Name); + if (refrig->NumPsPoints > 0) { print(state.files.debug, "Pressure Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", refrig.PsTemps(1) - incr); - for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.PsTemps(Loop)); - Temperature = refrig.PsTemps(Loop) + (refrig.PsTemps(Loop + 1) - refrig.PsTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", refrig->PsTemps(1) - incr); + for (int Loop = 1; Loop <= refrig->NumPsPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->PsTemps(Loop)); + Temperature = refrig->PsTemps(Loop) + (refrig->PsTemps(Loop + 1) - refrig->PsTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", refrig.PsTemps(refrig.NumPsPoints)); - print(state.files.debug, ",{:.2R}\n", refrig.PsTemps(refrig.NumPsPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig->PsTemps(refrig->NumPsPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->PsTemps(refrig->NumPsPoints) + incr); print(state.files.debug, "Saturated Pressures:"); - Temperature = refrig.PsTemps(1) - incr; - ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); + Temperature = refrig->PsTemps(1) - incr; + ReturnValue = refrig->getSatPressure(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= refrig.NumPsPoints - 1; ++Loop) { - Temperature = refrig.PsTemps(Loop); - ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); + for (int Loop = 1; Loop <= refrig->NumPsPoints - 1; ++Loop) { + Temperature = refrig->PsTemps(Loop); + ReturnValue = refrig->getSatPressure(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.PsTemps(Loop) + (refrig.PsTemps(Loop + 1) - refrig.PsTemps(Loop)) / 2.0; - ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); + Temperature = refrig->PsTemps(Loop) + (refrig->PsTemps(Loop + 1) - refrig->PsTemps(Loop)) / 2.0; + ReturnValue = refrig->getSatPressure(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = refrig.PsTemps(refrig.NumPsPoints); - ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); + Temperature = refrig->PsTemps(refrig->NumPsPoints); + ReturnValue = refrig->getSatPressure(state, Temperature, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.PsTemps(refrig.NumPsPoints) + incr; - ReturnValue = refrig.getSatPressure(state, Temperature, RoutineName); + Temperature = refrig->PsTemps(refrig->NumPsPoints) + incr; + ReturnValue = refrig->getSatPressure(state, Temperature, routineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Enthalpy from Temperatures - if (refrig.NumHPoints > 0) { + if (refrig->NumHPoints > 0) { print(state.files.debug, "Enthalpy Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", refrig.HTemps(1) - incr); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.HTemps(Loop)); - Temperature = refrig.HTemps(Loop) + (refrig.HTemps(Loop + 1) - refrig.HTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", refrig->HTemps(1) - incr); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->HTemps(Loop)); + Temperature = refrig->HTemps(Loop) + (refrig->HTemps(Loop + 1) - refrig->HTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", refrig.HTemps(refrig.NumHPoints)); - print(state.files.debug, ",{:.2R}\n", refrig.HTemps(refrig.NumHPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig->HTemps(refrig->NumHPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->HTemps(refrig->NumHPoints) + incr); print(state.files.debug, "Saturated Enthalpy:"); - Temperature = refrig.HTemps(1) - incr; - ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); + Temperature = refrig->HTemps(1) - incr; + ReturnValue = refrig->getSatEnthalpy(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= refrig.NumHPoints - 1; ++Loop) { - Temperature = refrig.HTemps(Loop); - ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); + for (int Loop = 1; Loop <= refrig->NumHPoints - 1; ++Loop) { + Temperature = refrig->HTemps(Loop); + ReturnValue = refrig->getSatEnthalpy(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.HTemps(Loop) + (refrig.HTemps(Loop + 1) - refrig.HTemps(Loop)) / 2.0; - ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); + Temperature = refrig->HTemps(Loop) + (refrig->HTemps(Loop + 1) - refrig->HTemps(Loop)) / 2.0; + ReturnValue = refrig->getSatEnthalpy(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = refrig.HTemps(refrig.NumHPoints); - ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); + Temperature = refrig->HTemps(refrig->NumHPoints); + ReturnValue = refrig->getSatEnthalpy(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.HTemps(refrig.NumHPoints) + incr; - ReturnValue = refrig.getSatEnthalpy(state, Temperature, Quality, RoutineName); + Temperature = refrig->HTemps(refrig->NumHPoints) + incr; + ReturnValue = refrig->getSatEnthalpy(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Specific Heat from Temperatures - if (refrig.NumCpPoints > 0) { + if (refrig->NumCpPoints > 0) { print(state.files.debug, "Specific Heat Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", refrig.CpTemps(1) - incr); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.CpTemps(Loop)); - Temperature = refrig.CpTemps(Loop) + (refrig.CpTemps(Loop + 1) - refrig.CpTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", refrig->CpTemps(1) - incr); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->CpTemps(Loop)); + Temperature = refrig->CpTemps(Loop) + (refrig->CpTemps(Loop + 1) - refrig->CpTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", refrig.CpTemps(refrig.NumCpPoints)); - print(state.files.debug, ",{:.2R}\n", refrig.CpTemps(refrig.NumCpPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig->CpTemps(refrig->NumCpPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->CpTemps(refrig->NumCpPoints) + incr); print(state.files.debug, "Saturated Specific Heat:"); - Temperature = refrig.CpTemps(1) - incr; - ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); + Temperature = refrig->CpTemps(1) - incr; + ReturnValue = refrig->getSatSpecificHeat(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= refrig.NumCpPoints - 1; ++Loop) { - Temperature = refrig.CpTemps(Loop); - ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); + for (int Loop = 1; Loop <= refrig->NumCpPoints - 1; ++Loop) { + Temperature = refrig->CpTemps(Loop); + ReturnValue = refrig->getSatSpecificHeat(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.CpTemps(Loop) + (refrig.CpTemps(Loop + 1) - refrig.CpTemps(Loop)) / 2.0; - ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); + Temperature = refrig->CpTemps(Loop) + (refrig->CpTemps(Loop + 1) - refrig->CpTemps(Loop)) / 2.0; + ReturnValue = refrig->getSatSpecificHeat(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = refrig.CpTemps(refrig.NumCpPoints); - ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); + Temperature = refrig->CpTemps(refrig->NumCpPoints); + ReturnValue = refrig->getSatSpecificHeat(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.CpTemps(refrig.NumCpPoints) + incr; - ReturnValue = refrig.getSatSpecificHeat(state, Temperature, Quality, RoutineName); + Temperature = refrig->CpTemps(refrig->NumCpPoints) + incr; + ReturnValue = refrig->getSatSpecificHeat(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } // ========= Density from Temperatures - if (refrig.NumRhoPoints > 0) { + if (refrig->NumRhoPoints > 0) { print(state.files.debug, "Density Results at Temperatures:"); - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(1) - incr); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(Loop)); - Temperature = refrig.RhoTemps(Loop) + (refrig.RhoTemps(Loop + 1) - refrig.RhoTemps(Loop)) / 2.0; + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(1) - incr); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(Loop)); + Temperature = refrig->RhoTemps(Loop) + (refrig->RhoTemps(Loop + 1) - refrig->RhoTemps(Loop)) / 2.0; print(state.files.debug, ",{:.2R}", Temperature); } - print(state.files.debug, ",{:.2R}", refrig.RhoTemps(refrig.NumRhoPoints)); - print(state.files.debug, ",{:.2R}\n", refrig.RhoTemps(refrig.NumRhoPoints) + incr); + print(state.files.debug, ",{:.2R}", refrig->RhoTemps(refrig->NumRhoPoints)); + print(state.files.debug, ",{:.2R}\n", refrig->RhoTemps(refrig->NumRhoPoints) + incr); print(state.files.debug, "Saturated Density:"); - Temperature = refrig.RhoTemps(1) - incr; - ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); + Temperature = refrig->RhoTemps(1) - incr; + ReturnValue = refrig->getSatDensity(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - for (int Loop = 1; Loop <= refrig.NumRhoPoints - 1; ++Loop) { - Temperature = refrig.RhoTemps(Loop); - ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); + for (int Loop = 1; Loop <= refrig->NumRhoPoints - 1; ++Loop) { + Temperature = refrig->RhoTemps(Loop); + ReturnValue = refrig->getSatDensity(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.RhoTemps(Loop) + (refrig.RhoTemps(Loop + 1) - refrig.RhoTemps(Loop)) / 2.0; - ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); + Temperature = refrig->RhoTemps(Loop) + (refrig->RhoTemps(Loop + 1) - refrig->RhoTemps(Loop)) / 2.0; + ReturnValue = refrig->getSatDensity(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); } - Temperature = refrig.RhoTemps(refrig.NumRhoPoints); - ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); + Temperature = refrig->RhoTemps(refrig->NumRhoPoints); + ReturnValue = refrig->getSatDensity(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}", ReturnValue); - Temperature = refrig.RhoTemps(refrig.NumRhoPoints) + incr; - ReturnValue = refrig.getSatDensity(state, Temperature, Quality, RoutineName); + Temperature = refrig->RhoTemps(refrig->NumRhoPoints) + incr; + ReturnValue = refrig->getSatDensity(state, Temperature, Quality, routineName); print(state.files.debug, ",{:.2R}\n", ReturnValue); } } @@ -3628,7 +2732,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSatPressure(state, Temperature, CalledFrom); + return df->refrigs(RefrigIndex)->getSatPressure(state, Temperature, CalledFrom); } //***************************************************************************** @@ -3736,7 +2840,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSatTemperature(state, Pressure, CalledFrom); + return df->refrigs(RefrigIndex)->getSatTemperature(state, Pressure, CalledFrom); } //***************************************************************************** @@ -3800,7 +2904,7 @@ namespace FluidProperties { return 0.0; } } - return df->RefrigData(RefrigIndex).getSatEnthalpy(state, Temperature, Quality, CalledFrom); + return df->refrigs(RefrigIndex)->getSatEnthalpy(state, Temperature, Quality, CalledFrom); } //***************************************************************************** @@ -3942,7 +3046,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSatDensity(state, Temperature, Quality, CalledFrom); + return df->refrigs(RefrigIndex)->getSatDensity(state, Temperature, Quality, CalledFrom); } //***************************************************************************** @@ -4023,7 +3127,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSatSpecificHeat(state, Temperature, Quality, CalledFrom); + return df->refrigs(RefrigIndex)->getSatSpecificHeat(state, Temperature, Quality, CalledFrom); } //***************************************************************************** @@ -4077,14 +3181,14 @@ namespace FluidProperties { int CurPresRangeErrCount = 0; // low index value of Temperature from table - int TempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); + int TempIndex = FindArrayIndex(Temperature, this->SupTemps, 1, this->NumSupTempPoints); // low index value of Pressure from table - int LoPressIndex = FindArrayIndex(Pressure, this->SHPress, 1, this->NumSuperPressPts); + int LoPressIndex = FindArrayIndex(Pressure, this->SupPress, 1, this->NumSupPressPoints); // check temperature data range and attempt to cap if necessary - if ((TempIndex > 0) && (TempIndex < this->NumSuperTempPts)) { // in range + if ((TempIndex > 0) && (TempIndex < this->NumSupTempPoints)) { // in range HiTempIndex = TempIndex + 1; - TempInterpRatio = (Temperature - this->SHTemps(TempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(TempIndex)); + TempInterpRatio = (Temperature - this->SupTemps(TempIndex)) / (this->SupTemps(HiTempIndex) - this->SupTemps(TempIndex)); } else if (TempIndex < 1) { ++CurTempRangeErrCount; ++ErrCount; @@ -4100,9 +3204,9 @@ namespace FluidProperties { } // check pressure data range and attempt to cap if necessary - if ((LoPressIndex > 0) && (LoPressIndex < this->NumSuperPressPts)) { // in range + if ((LoPressIndex > 0) && (LoPressIndex < this->NumSupPressPoints)) { // in range HiPressIndex = LoPressIndex + 1; - PressInterpRatio = (Pressure - this->SHPress(LoPressIndex)) / (this->SHPress(HiPressIndex) - this->SHPress(LoPressIndex)); + PressInterpRatio = (Pressure - this->SupPress(LoPressIndex)) / (this->SupPress(HiPressIndex) - this->SupPress(LoPressIndex)); } else if (LoPressIndex < 1) { ++CurPresRangeErrCount; ++ErrCount; @@ -4181,54 +3285,49 @@ namespace FluidProperties { return ReturnValue; } - if (!state.dataGlobal->WarmupFlag) { - // some checks... - if (ErrCount > 0) { - // send temp range error if flagged - this->errors[(int)RefrigError::SatSupEnthalpy].count += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupEnthalpyTemp].count <= df->RefrigErrorLimitTest) { + if (ErrCount > 0 && !state.dataGlobal->WarmupFlag) { + // send temp range error if flagged + this->errors[(int)RefrigError::SatSupEnthalpy].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupEnthalpyTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", - routineName, - this->Name)); + format("{}: Refrigerant [{}] Temperature is out of range for superheated enthalpy: values capped **", + routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurTempRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant enthalpy: values capped **", - routineName, - this->Name), - this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, - Temperature, - Temperature, - _, - "{C}", - "{C}"); - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated enthalpy: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, + Temperature, + Temperature, + _, + "{C}", + "{C}"); + } - // send pressure range error if flagged - this->errors[(int)RefrigError::SatSupEnthalpyPress].count += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupEnthalpyPress].count <= df->RefrigErrorLimitTest) { + // send pressure range error if flagged + this->errors[(int)RefrigError::SatSupEnthalpyPress].count += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupEnthalpyPress].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - routineName, - this->Name)); + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", + routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurPresRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupEnthalpyPress].index, - Pressure, - Pressure, - _, - "{Pa}", - "{Pa}"); - } - } // end error checking - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyPress].index, + Pressure, + Pressure, + _, + "{Pa}", + "{Pa}"); + } + } // end error checking return ReturnValue; } @@ -4275,7 +3374,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); + return df->refrigs(RefrigIndex)->getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); } //***************************************************************************** @@ -4339,10 +3438,10 @@ namespace FluidProperties { int CurSatErrCount = 0; // Index value of lower temperature from data - int LoTempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); + int LoTempIndex = FindArrayIndex(Temperature, this->SupTemps, 1, this->NumSupTempPoints); // check temperature data range and attempt to cap if necessary - if ((LoTempIndex > 0) && (LoTempIndex < this->NumSuperTempPts)) { // in range + if ((LoTempIndex > 0) && (LoTempIndex < this->NumSupTempPoints)) { // in range HiTempIndex = LoTempIndex + 1; } else if (LoTempIndex < 1) { // below lower bound ++CurTempRangeErrCount; @@ -4354,8 +3453,8 @@ namespace FluidProperties { } // check for lowest non-zero value in lower temp data - int LoTempStart = this->NumSuperPressPts; - for (int Loop = 1; Loop <= this->NumSuperPressPts; ++Loop) { + int LoTempStart = this->NumSupPressPoints; + for (int Loop = 1; Loop <= this->NumSupPressPoints; ++Loop) { if (this->HshValues(Loop, LoTempIndex) > 0.0) { LoTempStart = Loop; break; @@ -4363,15 +3462,15 @@ namespace FluidProperties { } // check for highest non-zero value in lower temp data int LoTempFinish = 1; - for (int Loop = this->NumSuperPressPts; Loop >= 1; --Loop) { + for (int Loop = this->NumSupPressPoints; Loop >= 1; --Loop) { if (this->HshValues(Loop, LoTempIndex) <= 0.0) { LoTempFinish = Loop; // EXIT } } // check for lowest non-zero value in high temp data - int HiTempStart = this->NumSuperPressPts; - for (int Loop = 1; Loop <= this->NumSuperPressPts; ++Loop) { + int HiTempStart = this->NumSupPressPoints; + for (int Loop = 1; Loop <= this->NumSupPressPoints; ++Loop) { if (this->HshValues(Loop, HiTempIndex) > 0.0) { HiTempStart = Loop; break; @@ -4380,7 +3479,7 @@ namespace FluidProperties { // check for highest non-zero value in high temp data int HiTempFinish = 1; - for (int Loop = this->NumSuperPressPts; Loop >= 1; --Loop) { + for (int Loop = this->NumSupPressPoints; Loop >= 1; --Loop) { if (this->HshValues(Loop, HiTempIndex) <= 0.0) { HiTempFinish = Loop; } @@ -4392,7 +3491,7 @@ namespace FluidProperties { int TempFinish = min(LoTempFinish, HiTempFinish); // calculate interpolation ratio w.r.t temperature // This ratio is used to find enthalpies at the given temperature - Real64 TempInterpRatio = (Temperature - this->SHTemps(LoTempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(LoTempIndex)); + Real64 TempInterpRatio = (Temperature - this->SupTemps(LoTempIndex)) / (this->SupTemps(HiTempIndex) - this->SupTemps(LoTempIndex)); // search for array index by bisection int start = TempStart; // set the bounds @@ -4418,10 +3517,10 @@ namespace FluidProperties { ++ErrCount; if (Enthalpy > EnthalpyMax) { // return min pressure - ReturnValue = this->SHPress(HiTempStart); + ReturnValue = this->SupPress(HiTempStart); } else { // return max pressure - ReturnValue = this->SHPress(LoTempFinish); + ReturnValue = this->SupPress(LoTempFinish); } } else { // go ahead and search @@ -4450,81 +3549,76 @@ namespace FluidProperties { // calculate an interpolation ratio EnthInterpRatio = (Enthalpy - EnthalpyLow) / (EnthalpyHigh - EnthalpyLow); // apply this interpolation ratio to find the final pressure - ReturnValue = this->SHPress(LoEnthalpyIndex) + EnthInterpRatio * (this->SHPress(HiEnthalpyIndex) - this->SHPress(LoEnthalpyIndex)); + ReturnValue = this->SupPress(LoEnthalpyIndex) + EnthInterpRatio * (this->SupPress(HiEnthalpyIndex) - this->SupPress(LoEnthalpyIndex)); } - if (!state.dataGlobal->WarmupFlag) { - // ** make error checks ** - if (ErrCount > 0) { - // send near saturation warning if flagged - this->errors[(int)RefrigError::SatSupPress].count += CurSatErrCount; - // send warning + if (ErrCount > 0 && !state.dataGlobal->WarmupFlag) { + // send near saturation warning if flagged + this->errors[(int)RefrigError::SatSupPress].count += CurSatErrCount; + // send warning + if (CurSatErrCount > 0) { if (this->errors[(int)RefrigError::SatSupPress].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " - "temperature returned. **", - routineName, - this->Name)); + "temperature returned. **", routineName, this->Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant Enthalpy = {:.3R}", Enthalpy)); ShowContinueError(state, format("Returned Pressure value = {:.0R}", ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } - if (CurSatErrCount > 0) { - ShowRecurringSevereErrorAtEnd(state, - format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupPress].index, - ReturnValue, - ReturnValue, - _, - "{Pa}", - "{Pa}"); - } + ShowRecurringSevereErrorAtEnd(state, + format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPress].index, + ReturnValue, + ReturnValue, + _, + "{Pa}", + "{Pa}"); + } - // send temp range error if flagged - this->errors[(int)RefrigError::SatSupPressTemp].count += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupPressTemp].count <= df->RefrigErrorLimitTest) { + // send temp range error if flagged + this->errors[(int)RefrigError::SatSupPressTemp].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupPressTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", - routineName, - this->Name)); + format("{}: Refrigerant [{}] Temperature is out of range for superheated pressure: values capped **", + routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurTempRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant pressure: values capped **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupPressTemp].index, - Temperature, - Temperature, - _, - "{C}", - "{C}"); - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated pressure: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressTemp].index, + Temperature, + Temperature, + _, + "{C}", + "{C}"); + } - // send enthalpy range error if flagged - this->errors[(int)RefrigError::SatSupPressEnthalpy].count += CurEnthalpyRangeErrCount; - if (CurEnthalpyRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupPressEnthalpy].count <= df->RefrigErrorLimitTest) { + // send enthalpy range error if flagged + this->errors[(int)RefrigError::SatSupPressEnthalpy].count += CurEnthalpyRangeErrCount; + if (CurEnthalpyRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupPressEnthalpy].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant enthalpy: values capped **", - routineName, - this->Name)); + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", + routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurEnthalpyRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant pressure: values capped **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupPressEnthalpy].index, - Enthalpy, - Enthalpy, - _, - "{J}", - "{J}"); - } - } // end error checking - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated pressure: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressEnthalpy].index, + Enthalpy, + Enthalpy, + _, + "{J}", + "{J}"); + } + } // end error checking return ReturnValue; } @@ -4569,7 +3663,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSupHeatPressure(state, Temperature, Enthalpy, CalledFrom); + return df->refrigs(RefrigIndex)->getSupHeatPressure(state, Temperature, Enthalpy, CalledFrom); } //***************************************************************************** @@ -4591,7 +3685,7 @@ namespace FluidProperties { // enthalpy and pressure. Works only in superheated region. // METHODOLOGY EMPLOYED: - // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. + // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig-> // Return value Real64 ReturnValue; @@ -4692,7 +3786,7 @@ namespace FluidProperties { // enthalpy and pressure. Works only in superheated region. // METHODOLOGY EMPLOYED: - // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig. + // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -4703,7 +3797,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); + return df->refrigs(RefrigIndex)->getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); } //***************************************************************************** @@ -4759,10 +3853,10 @@ namespace FluidProperties { // check temperature data range and attempt to cap if necessary // low index value of Temperature from table - int TempIndex = FindArrayIndex(Temperature, this->SHTemps, 1, this->NumSuperTempPts); - if ((TempIndex > 0) && (TempIndex < this->NumSuperTempPts)) { // in range + int TempIndex = FindArrayIndex(Temperature, this->SupTemps, 1, this->NumSupTempPoints); + if ((TempIndex > 0) && (TempIndex < this->NumSupTempPoints)) { // in range HiTempIndex = TempIndex + 1; - TempInterpRatio = (Temperature - this->SHTemps(TempIndex)) / (this->SHTemps(HiTempIndex) - this->SHTemps(TempIndex)); + TempInterpRatio = (Temperature - this->SupTemps(TempIndex)) / (this->SupTemps(HiTempIndex) - this->SupTemps(TempIndex)); } else if (TempIndex < 1) { ++CurTempRangeErrCount; ++ErrCount; @@ -4779,11 +3873,11 @@ namespace FluidProperties { } // check pressure data range and attempt to cap if necessary - int LoPressIndex = FindArrayIndex(Pressure, this->SHPress, 1, this->NumSuperPressPts); - if ((LoPressIndex > 0) && (LoPressIndex < this->NumSuperPressPts)) { // in range + int LoPressIndex = FindArrayIndex(Pressure, this->SupPress, 1, this->NumSupPressPoints); + if ((LoPressIndex > 0) && (LoPressIndex < this->NumSupPressPoints)) { // in range HiPressIndex = LoPressIndex + 1; - Real64 const SHPress_Lo = this->SHPress(LoPressIndex); - PressInterpRatio = (Pressure - SHPress_Lo) / (this->SHPress(HiPressIndex) - SHPress_Lo); + Real64 const SHPress_Lo = this->SupPress(LoPressIndex); + PressInterpRatio = (Pressure - SHPress_Lo) / (this->SupPress(HiPressIndex) - SHPress_Lo); } else if (LoPressIndex < 1) { ++CurPresRangeErrCount; ++ErrCount; @@ -4865,51 +3959,47 @@ namespace FluidProperties { return saturated_density; } - if (!state.dataGlobal->WarmupFlag) { - // some checks... - if (ErrCount > 0) { - // send temp range error if flagged - this->errors[(int)RefrigError::SatSupDensityTemp].count += CurTempRangeErrCount; - if (CurTempRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupDensityTemp].count <= df->RefrigErrorLimitTest) { - ShowWarningMessage( - state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", - routineName, - this->Name)); + if (ErrCount > 0 && !state.dataGlobal->WarmupFlag) { + // send temp range error if flagged + this->errors[(int)RefrigError::SatSupDensityTemp].count += CurTempRangeErrCount; + if (CurTempRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupDensityTemp].count <= df->RefrigErrorLimitTest) { + ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", + routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurTempRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated refrigerant density: values capped **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupDensityTemp].index, - Temperature, - Temperature, - _, - "{C}", - "{C}"); - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityTemp].index, + Temperature, + Temperature, + _, + "{C}", + "{C}"); + } - // send pressure range error if flagged - this->errors[(int)RefrigError::SatSupDensityPress].count += CurPresRangeErrCount; - if (CurPresRangeErrCount > 0 && this->errors[(int)RefrigError::SatSupDensityPress].count <= df->RefrigErrorLimitTest) { + // send pressure range error if flagged + this->errors[(int)RefrigError::SatSupDensityPress].count += CurPresRangeErrCount; + if (CurPresRangeErrCount > 0) { + if (this->errors[(int)RefrigError::SatSupDensityPress].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", + format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - if (CurPresRangeErrCount > 0) { - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated refrigerant density: values capped **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupDensityPress].index, - Pressure, - Pressure, - _, - "{Pa}", - "{Pa}"); - } + ShowRecurringWarningErrorAtEnd(state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", + routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityPress].index, + Pressure, + Pressure, + _, + "{Pa}", + "{Pa}"); } // end error checking } @@ -4956,7 +4046,7 @@ namespace FluidProperties { } } - return df->RefrigData(RefrigIndex).getSupHeatDensity(state, Temperature, Pressure, CalledFrom); + return df->refrigs(RefrigIndex)->getSupHeatDensity(state, Temperature, Pressure, CalledFrom); } //***************************************************************************** @@ -5025,11 +4115,7 @@ namespace FluidProperties { auto &df = state.dataFluidProps; // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!this->CpDataPresent) { - ShowSevereError(state, format("{}: specific heat data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); - ShowFatalError(state, "Program terminates due to preceding condition."); - return 0.0; - } + assert(this->CpDataPresent); // Now determine the value of specific heat using interpolation if (Temperature < this->CpLowTempValue) { // Temperature too low @@ -5101,7 +4187,9 @@ namespace FluidProperties { int mid = ((beg + end) >> 1); // bit shifting is faster than /2 (Temperature > this->CpTemps(mid) ? beg : end) = mid; } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] - return GetInterpValue_fast(Temperature, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); + + // Is this faster than Interp? + return this->CpValues(end) - (this->CpTemps(end) - Temperature) * this->CpTempRatios(beg); } } @@ -5112,25 +4200,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // FUNCTION INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - - // PURPOSE OF THIS FUNCTION: - // This subroutine finds specific heats for glycols at different - // temperatures. - - // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find specific heat values for a - // particular glycol (water or some mixture of water and another fluid). - // Warnings are given if the point is not clearly in the bounds of the - // glycol data. The value returned is the appropriate limit value. - - // REFERENCES: - // GetFluidPropertiesData: subroutine enforces that temperatures in - // all temperature lists are entered in ascending order. - + // This is now just a wrapper for the GlycolProps::getSpecificHeat method auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -5141,7 +4211,7 @@ namespace FluidProperties { } } - return df->GlycolData(GlycolIndex).getSpecificHeat(state, Temperature, CalledFrom); + return df->glycols(GlycolIndex)->getSpecificHeat(state, Temperature, CalledFrom); } //***************************************************************************** @@ -5182,11 +4252,7 @@ namespace FluidProperties { GlycolError error = GlycolError::Invalid; // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - if (!this->RhoDataPresent) { - ShowSevereError(state, format("{}: density data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); - ShowFatalError(state, "Program terminates due to preceding condition."); - return 0.0; - } + assert(this->RhoDataPresent); // Now determine the value of specific heat using interpolation if (Temperature < this->RhoLowTempValue) { // Temperature too low @@ -5196,29 +4262,27 @@ namespace FluidProperties { error = GlycolError::DensityHigh; ReturnValue = this->RhoValues(this->RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPts); + int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPoints); Real64 TempInterpRatio = (Temperature - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); ReturnValue = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); } // Error handling - if (!state.dataGlobal->WarmupFlag) { - if (error != GlycolError::Invalid) { - df->glycolErrorLimits[(int)error] = this->errors[(int)error].count; - } + if (error != GlycolError::Invalid && !state.dataGlobal->WarmupFlag) { + df->glycolErrorLimits[(int)error] = this->errors[(int)error].count; - if ((error == GlycolError::DensityLow) && - (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest)) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] density **", routineName, this->Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->RhoLowTempValue, - this->RhoHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } if (error == GlycolError::DensityLow) { + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] density **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->RhoLowTempValue, + this->RhoHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } + ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityLow].index, @@ -5227,20 +4291,18 @@ namespace FluidProperties { _, "{C}", "{C}"); - } - - if ((error == GlycolError::DensityHigh) && - (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest)) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] density **", routineName, this->Name)); - ShowContinueError(state, - format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", - CalledFrom, - Temperature, - this->RhoLowTempValue, - this->RhoHighTempValue)); - ShowContinueErrorTimeStamp(state, ""); - } - if (error == GlycolError::DensityHigh) { + + } else { // error == GlycolError::DensityHigh + if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { + ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] density **", routineName, this->Name)); + ShowContinueError(state, + format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", + CalledFrom, + Temperature, + this->RhoLowTempValue, + this->RhoHighTempValue)); + ShowContinueErrorTimeStamp(state, ""); + } ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityHigh].index, @@ -5262,25 +4324,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // FUNCTION INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - - // PURPOSE OF THIS FUNCTION: - // This subroutine finds the density for glycols at different - // temperatures. - - // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find density values for a - // particular glycol (water or some mixture of water and another fluid). - // Warnings are given if the point is not clearly in the bounds of the - // glycol data. The value returned is the appropriate limit value. - - // REFERENCES: - // GetFluidPropertiesData: subroutine enforces that temperatures in - // all temperature lists are entered in ascending order. - + // This is now just a wrapper for the GlycolProps::getDensity method auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -5291,7 +4335,7 @@ namespace FluidProperties { } } - return df->GlycolData(GlycolIndex).getDensity(state, Temperature, CalledFrom); + return df->glycols(GlycolIndex)->getDensity(state, Temperature, CalledFrom); } //***************************************************************************** @@ -5346,7 +4390,7 @@ namespace FluidProperties { error = GlycolError::ConductivityHigh; ReturnValue = this->CondValues(this->CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPts); + int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPoints); Real64 TempInterpRatio = (Temperature - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); ReturnValue = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); } @@ -5410,24 +4454,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // FUNCTION INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - - // PURPOSE OF THIS FUNCTION: - // This subroutine finds the conductivity for glycols at different - // temperatures. - - // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find conductivity values for a - // particular glycol (water or some mixture of water and another fluid). - // Warnings are given if the point is not clearly in the bounds of the - // glycol data. The value returned is the appropriate limit value. - - // REFERENCES: - // GetFluidPropertiesData: subroutine enforces that temperatures in - // all temperature lists are entered in ascending order. + // This is now just a wrapper for the GlycolProps::getConductivity method auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -5439,7 +4466,7 @@ namespace FluidProperties { } // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value - return df->GlycolData(GlycolIndex).getConductivity(state, Temperature, CalledFrom); + return df->glycols(GlycolIndex)->getConductivity(state, Temperature, CalledFrom); } //***************************************************************************** @@ -5494,7 +4521,7 @@ namespace FluidProperties { error = GlycolError::ViscosityHigh; ReturnValue = this->ViscValues(this->ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - int LoTempIndex = FindArrayIndex(Temperature, this->ViscTemps, 1, this->NumViscTempPts); + int LoTempIndex = FindArrayIndex(Temperature, this->ViscTemps, 1, this->NumViscTempPoints); Real64 TempInterpRatio = (Temperature - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); ReturnValue = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); } @@ -5525,7 +4552,7 @@ namespace FluidProperties { "{C}"); } - if (error == GlycolError::ViscosityHigh) { + else if (error == GlycolError::ViscosityHigh) { if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] viscosity **", routineName, this->Name)); ShowContinueError(state, @@ -5558,24 +4585,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // FUNCTION INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - - // PURPOSE OF THIS FUNCTION: - // This subroutine finds the viscosity for glycols at different - // temperatures. - - // METHODOLOGY EMPLOYED: - // Linear interpolation is used to find viscosity values for a - // particular glycol (water or some mixture of water and another fluid). - // Warnings are given if the point is not clearly in the bounds of the - // glycol data. The value returned is the appropriate limit value. - - // REFERENCES: - // GetFluidPropertiesData: subroutine enforces that temperatures in - // all temperature lists are entered in ascending order. + // This is now just a wrapper for the GlycolProps::getViscosity method auto &df = state.dataFluidProps; @@ -5588,19 +4598,13 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - return df->GlycolData(GlycolIndex).getViscosity(state, Temperature, CalledFrom); + return df->glycols(GlycolIndex)->getViscosity(state, Temperature, CalledFrom); } //***************************************************************************** - void GetInterpValue_error(EnergyPlusData &state) - { - ShowFatalError(state, "GetInterpValue: Temperatures for fluid property data too close together, division by zero"); - } - - int GetRefrigNum(EnergyPlusData &state, std::string_view const name) // carries in substance name + int GetRefrigNum(EnergyPlusData &state, std::string_view const refrigName) // carries in substance name { - // FUNCTION INFORMATION: // AUTHOR Rick Strand // DATE WRITTEN May 2000 @@ -5609,42 +4613,28 @@ namespace FluidProperties { // PURPOSE OF THIS FUNCTION: // This function simply determines the index of the refrigerant named // in the input variable to this routine within the derived type. - - // METHODOLOGY EMPLOYED: - // Just checks to see whether or not the refrigerant name coming in can - // be found in the refrigerant derived type. If so, the function is set - // to the index within the derived type. If the input has not been read - // yet for some reason, that must be done. - - // Check to see if this glycol shows up in the glycol data auto &df = state.dataFluidProps; - if (df->NumOfRefrigerants == 0) { - ShowSevereError(state, "No refrigerants found."); - ShowFatalError(state, "Program terminates due to preceding condition."); - return 0; - } - - int refrigNum = Util::FindItemInList(Util::makeUPPER(name), df->RefrigData); + auto found = std::find_if(df->refrigs.begin(), df->refrigs.end(), + [refrigName](RefrigProps const *refrig) { return refrig->Name == refrigName; }); - if (refrigNum > 0) { - df->RefrigData(refrigNum).used = true; - } + if (found == df->refrigs.end()) return 0; + int refrigNum = (found - df->refrigs.begin()) + 1; + df->refrigs(refrigNum)->used = true; return refrigNum; } - RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view const name) { + RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view const refrigName) { auto &df = state.dataFluidProps; - int refrigNum = GetRefrigNum(state, name); - return (refrigNum > 0) ? &df->RefrigData(refrigNum) : nullptr; + int refrigNum = GetRefrigNum(state, refrigName); + return (refrigNum > 0) ? df->refrigs(refrigNum) : nullptr; } //***************************************************************************** - int GetGlycolNum(EnergyPlusData &state, std::string_view const name) // carries in substance name + int GetGlycolNum(EnergyPlusData &state, std::string_view const glycolName) // carries in substance name { - // FUNCTION INFORMATION: // AUTHOR Rick Strand // DATE WRITTEN May 2000 @@ -5653,36 +4643,43 @@ namespace FluidProperties { // PURPOSE OF THIS FUNCTION: // This function simply determines the index of the glycol named // in the input variable to this routine within the derived type. - - // METHODOLOGY EMPLOYED: - // Just checks to see whether or not the glycol name coming in can - // be found in the glycol derived type. If so, the function is set - // to the index within the derived type. If the input has not been read - // yet for some reason, that must be done. - - // Check to see if this glycol shows up in the glycol data auto &df = state.dataFluidProps; - if (df->NumOfGlycols == 0) { - ShowSevereError(state, "No glycols found."); - ShowFatalError(state, "Program terminates due to preceding condition."); - return 0; - } - int glycolNum = Util::FindItemInList(Util::makeUPPER(name), df->GlycolData, df->NumOfGlycols); + auto found = std::find_if(df->glycols.begin(), df->glycols.end(), + [glycolName](GlycolProps const *glycol) { return glycol->Name == glycolName; }); - if (glycolNum > 0) { - df->GlycolData(glycolNum).used = true; - } + if (found == df->glycols.end()) return 0; + int glycolNum = (found - df->glycols.begin()) + 1; + df->glycols(glycolNum)->used = true; return glycolNum; } GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view const glycolName) { auto &df = state.dataFluidProps; int glycolNum = GetGlycolNum(state, glycolName); - return (glycolNum > 0) ? &df->GlycolData(glycolNum) : nullptr; + return (glycolNum > 0) ? df->glycols(glycolNum) : nullptr; + } + + int GetGlycolRawNum(EnergyPlusData &state, std::string_view const glycolRawName) // carries in substance name + { + auto &df = state.dataFluidProps; + + auto found = std::find_if(df->glycolsRaw.begin(), df->glycolsRaw.end(), + [glycolRawName](GlycolRawProps const *glycolRaw) { return glycolRaw->Name == glycolRawName; }); + + if (found == df->glycolsRaw.end()) return 0; + + int glycolRawNum = (found - df->glycolsRaw.begin()) + 1; + return glycolRawNum; } + GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view const glycolRawName) { + auto &df = state.dataFluidProps; + int glycolRawNum = GetGlycolRawNum(state, glycolRawName); + return (glycolRawNum > 0) ? df->glycolsRaw(glycolRawNum) : nullptr; + } + //***************************************************************************** std::string GetGlycolNameByIndex(EnergyPlusData &state, int const Idx) // carries in substance index @@ -5707,8 +4704,8 @@ namespace FluidProperties { // ArrayLength = SIZE(GlycolData) auto &df = state.dataFluidProps; - if (Idx > 0 && Idx <= df->NumOfGlycols) { - return df->GlycolData(Idx).Name; + if (Idx > 0 && Idx <= df->glycols.isize()) { + return df->glycols(Idx)->Name; } else { // return blank - error checking in calling proceedure return ""; } @@ -5906,8 +4903,8 @@ namespace FluidProperties { //***************************************************************************** - int CheckFluidPropertyName(EnergyPlusData &state, - std::string const &NameToCheck) // Name from input(?) to be checked against valid FluidPropertyNames + bool CheckFluidPropertyName(EnergyPlusData &state, + std::string const &name) // Name from input(?) to be checked against valid FluidPropertyNames { // FUNCTION INFORMATION: @@ -5918,16 +4915,13 @@ namespace FluidProperties { // This function checks on an input fluid property to make sure it is valid. auto &df = state.dataFluidProps; - // Item must be either in Refrigerant or Glycol list - int Found = 0; - if (df->NumOfRefrigerants > 0) { - Found = Util::FindItemInList(NameToCheck, df->RefrigData); - } - if (Found == 0 && df->NumOfGlycols > 0) { - Found = Util::FindItemInList(NameToCheck, df->GlycolData, df->NumOfGlycols); // GlycolData is allocated to NumOfGlyConcs - } + auto foundRefrig = std::find_if(df->refrigs.begin(), df->refrigs.end(), [name](RefrigProps const *refrig){ return refrig->Name == name; }); + if (foundRefrig != df->refrigs.end()) return true; + + auto foundGlycol = std::find_if(df->glycols.begin(), df->glycols.end(), [name](GlycolProps const *glycol){ return glycol->Name == name; }); + if (foundGlycol != df->glycols.end()) return true; - return Found; + return false; } void ReportOrphanFluids(EnergyPlusData &state) @@ -5946,16 +4940,16 @@ namespace FluidProperties { auto &df = state.dataFluidProps; - for (int Item = 1; Item <= df->NumOfRefrigerants; ++Item) { - if (df->RefrigData(Item).used) continue; - if (Util::SameString(df->RefrigData(Item).Name, Steam)) continue; + for (auto const *refrig : df->refrigs) { + if (refrig->used) continue; + if (refrig->Name == "STEAM") continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Refrigerant={}", df->RefrigData(Item).Name)); + ShowMessage(state, format("Refrigerant={}", refrig->Name)); } else { ++NumUnusedRefrig; } @@ -5963,18 +4957,18 @@ namespace FluidProperties { int NumUnusedGlycol = 0; - for (int Item = 1; Item <= df->NumOfGlycols; ++Item) { - if (df->GlycolData(Item).used) continue; - if (Util::SameString(df->GlycolData(Item).Name, Water)) continue; - if (Util::SameString(df->GlycolData(Item).Name, EthyleneGlycol)) continue; - if (Util::SameString(df->GlycolData(Item).Name, PropyleneGlycol)) continue; + for (auto const *glycol : df->glycols) { + if (glycol->used) continue; + if (glycol->Name == "WATER") continue; + if (glycol->Name == "ETHYLENEGLYCOL") continue; + if (glycol->Name == "PROPYLENEGLYCOL") continue; if (NeedOrphanMessage && state.dataGlobal->DisplayUnusedObjects) { ShowWarningError(state, "The following fluid names are \"Unused Fluids\". These fluids are in the idf"); ShowContinueError(state, " file but are never obtained by the simulation and therefore are NOT used."); NeedOrphanMessage = false; } if (state.dataGlobal->DisplayUnusedObjects) { - ShowMessage(state, format("Glycol={}", df->GlycolData(Item).Name)); + ShowMessage(state, format("Glycol={}", glycol->Name)); } else { ++NumUnusedGlycol; } @@ -5992,8 +4986,8 @@ namespace FluidProperties { { if (FluidIndex > 0) { auto &df = state.dataFluidProps; - MinTempLimit = df->GlycolData(FluidIndex).RhoLowTempValue; - MaxTempLimit = df->GlycolData(FluidIndex).RhoHighTempValue; + MinTempLimit = df->glycols(FluidIndex)->RhoLowTempValue; + MaxTempLimit = df->glycols(FluidIndex)->RhoHighTempValue; } } @@ -6001,8 +4995,8 @@ namespace FluidProperties { { if (FluidIndex > 0) { auto &df = state.dataFluidProps; - MinTempLimit = df->GlycolData(FluidIndex).CpLowTempValue; - MaxTempLimit = df->GlycolData(FluidIndex).CpHighTempValue; + MinTempLimit = df->glycols(FluidIndex)->CpLowTempValue; + MaxTempLimit = df->glycols(FluidIndex)->CpHighTempValue; } } diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 7e5fd99334a..5c4862c0d18 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -69,30 +69,6 @@ struct EnergyPlusData; namespace FluidProperties { - int constexpr EthyleneGlycolIndex = -2; - int constexpr PropyleneGlycolIndex = -1; - - constexpr int DefaultNumGlyTemps(33); // Temperature dimension of default glycol data - constexpr int DefaultNumGlyConcs(10); // Concentration dimension of default glycol data - constexpr int DefaultNumSteamTemps(111); // Temperature dimension of default steam data. - constexpr int DefaultNumSteamSuperheatedTemps(114); // Temperature dimension of default steam data. - constexpr int DefaultNumSteamSuperheatedPressure(114); // Temperature dimension of default steam data. - - constexpr static std::string_view Refrig("REFRIGERANT"); - constexpr static std::string_view Glycol("GLYCOL"); - constexpr static std::string_view Pressure("PRESSURE"); - constexpr static std::string_view Enthalpy("ENTHALPY"); - constexpr static std::string_view Density("DENSITY"); - constexpr static std::string_view SpecificHeat("SPECIFICHEAT"); - constexpr static std::string_view Conductivity("CONDUCTIVITY"); - constexpr static std::string_view Viscosity("VISCOSITY"); - constexpr static std::string_view Fluid("FLUID"); - constexpr static std::string_view GasFluid("FLUIDGAS"); - constexpr static std::string_view Water("Water"); - constexpr static std::string_view Steam("Steam"); - constexpr static std::string_view EthyleneGlycol("EthyleneGlycol"); - constexpr static std::string_view PropyleneGlycol("PropyleneGlycol"); - #ifdef EP_cache_GlycolSpecificHeat int constexpr t_sh_cache_size = 1024 * 1024; int constexpr t_sh_precision_bits = 24; @@ -124,6 +100,9 @@ namespace FluidProperties { int Num = 0; bool used = false; + std::string satTempArrayName; // Array of saturated temperature points, must be same for all properties + std::string supTempArrayName; // Array of superheated temperature points, must be same for all properties + int NumPsPoints = 0; // Number of saturation pressure Real64 PsLowTempValue = 0.0; // Low Temperature Value for Ps (>0.0) Real64 PsHighTempValue = 0.0; // High Temperature Value for Ps (max in tables) @@ -135,7 +114,8 @@ namespace FluidProperties { int PsHighPresIndex = 0; // High Pressure Max Index for Ps (>0.0) Array1D PsTemps; // Temperatures for saturation pressures Array1D PsValues; // Saturation pressures at PsTemps - + Array1D PsTempRatios; // PsTempRatios(i) = (PsValues(i+1) - PsValues(i)) / (PsTemps(i+1) - PsTemps(i)). Speed optimization. + int NumHPoints = 0; // Number of enthalpy points Real64 HfLowTempValue = 0.0; // Low Temperature Value for Hf (>0.0) Real64 HfHighTempValue = 0.0; // High Temperature Value for Hf (max in tables) @@ -148,7 +128,9 @@ namespace FluidProperties { Array1D HTemps; // Temperatures for enthalpy points Array1D HfValues; // Enthalpy of saturated fluid at HTemps Array1D HfgValues; // Enthalpy of saturated fluid/gas at HTemps - + Array1D HfTempRatios; + Array1D HfgTempRatios; + int NumCpPoints = 0; // Number of specific heat of fluid points Real64 CpfLowTempValue = 0.0; // Low Temperature Value for Cpf (>0.0) Real64 CpfHighTempValue = 0.0; // High Temperature Value for Cpf (max in tables) @@ -161,7 +143,9 @@ namespace FluidProperties { Array1D CpTemps; // Temperatures for specific heat points Array1D CpfValues; // Specific heat of saturated fluid at CpTemps Array1D CpfgValues; // Specific heat of saturated fluid/gas at CpTemps - + Array1D CpfTempRatios; + Array1D CpfgTempRatios; + int NumRhoPoints = 0; // Number of density of fluid points Real64 RhofLowTempValue = 0.0; // Low Temperature Value for Rhof (>0.0) Real64 RhofHighTempValue = 0.0; // High Temperature Value for Rhof (max in tables) @@ -174,11 +158,13 @@ namespace FluidProperties { Array1D RhoTemps; // Temperatures for density of fluid points Array1D RhofValues; // Density of saturated fluid at RhoTemps Array1D RhofgValues; // Density of saturated fluid/gas at RhoTemps - - int NumSuperTempPts = 0; // Number of temperature points for superheated enthalpy - int NumSuperPressPts = 0; // Number of pressure points for superheated enthalpy - Array1D SHTemps; // Temperatures for superheated gas - Array1D SHPress; // Pressures for superheated gas + Array1D RhofTempRatios; + Array1D RhofgTempRatios; + + int NumSupTempPoints = 0; // Number of temperature points for superheated enthalpy + int NumSupPressPoints = 0; // Number of pressure points for superheated enthalpy + Array1D SupTemps; // Temperatures for superheated gas + Array1D SupPress; // Pressures for superheated gas Array2D HshValues; // Enthalpy of superheated gas at HshTemps, HshPress Array2D RhoshValues; // Density of superheated gas at HshTemps, HshPress @@ -254,31 +240,35 @@ namespace FluidProperties { // Members std::string Name; // Name of the glycol int Num = 0; - + + std::string CpTempArrayName; bool CpDataPresent = false; // Flag set when specific heat data is available - int NumCpTempPts = 0; // Number of temperature points for specific heat - int NumCpConcPts = 0; // Number of concentration points for specific heat + int NumCpTempPoints = 0; // Number of temperature points for specific heat + int NumCpConcPoints = 0; // Number of concentration points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpConcs; // Concentration for specific heat of glycol Array2D CpValues; // Specific heat data values + std::string RhoTempArrayName; bool RhoDataPresent = false; // Flag set when density data is available - int NumRhoTempPts = 0; // Number of temperature points for density - int NumRhoConcPts = 0; // Number of concentration points for density + int NumRhoTempPoints = 0; // Number of temperature points for density + int NumRhoConcPoints = 0; // Number of concentration points for density Array1D RhoTemps; // Temperatures for density of glycol Array1D RhoConcs; // Concentration for density of glycol Array2D RhoValues; // Density data values + std::string CondTempArrayName; bool CondDataPresent = false; // Flag set when conductivity data is available - int NumCondTempPts = 0; // Number of temperature points for conductivity - int NumCondConcPts = 0; // Number of concentration points for conductivity + int NumCondTempPoints = 0; // Number of temperature points for conductivity + int NumCondConcPoints = 0; // Number of concentration points for conductivity Array1D CondTemps; // Temperatures for conductivity of glycol Array1D CondConcs; // Concentration for conductivity of glycol Array2D CondValues; // conductivity values + std::string ViscTempArrayName; bool ViscDataPresent = false; // Flag set when viscosity data is available - int NumViscTempPts = 0; // Number of temperature points for viscosity - int NumViscConcPts = 0; // Number of concentration points for viscosity + int NumViscTempPoints = 0; // Number of temperature points for viscosity + int NumViscConcPoints = 0; // Number of concentration points for viscosity Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscConcs; // Concentration for viscosity of glycol Array2D ViscValues; // viscosity values @@ -296,43 +286,47 @@ namespace FluidProperties { int BaseGlycolIndex = 0; // Index in user defined glycol data (>0 = index in raw data, // -1=propylene glycol, -2=ethylene glycol) Real64 Concentration = 0.0; // Concentration (if applicable) - + bool CpDataPresent = false; // Flag set when specific heat data is available Real64 CpLowTempValue = 0.0; // Low Temperature Value for Cp (>0.0) Real64 CpHighTempValue = 0.0; // High Temperature Value for Cp (max in tables) int CpLowTempIndex = 0; // Low Temperature Min Index for Cp (>0.0) int CpHighTempIndex = 0; // High Temperature Max Index for Cp (>0.0) - int NumCpTempPts = 0; // Number of temperature points for specific heat + int NumCpTempPoints = 0; // Number of temperature points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpValues; // Specific heat data values (J/kg-K) - + Array1D CpTempRatios; // Speed optimization + bool RhoDataPresent = false; // Flag set when density data is available - int NumRhoTempPts = 0.0; // Number of temperature points for density + int NumRhoTempPoints = 0.0; // Number of temperature points for density Real64 RhoLowTempValue = 0.0; // Low Temperature Value for Rho (>0.0) Real64 RhoHighTempValue = 0.0; // High Temperature Value for Rho (max in tables) int RhoLowTempIndex = 0; // Low Temperature Min Index for Rho (>0.0) int RhoHighTempIndex = 0; // High Temperature Max Index for Rho (>0.0) Array1D RhoTemps; // Temperatures for density of glycol Array1D RhoValues; // Density data values (kg/m3) - + Array1D RhoTempRatios; // Speed optimization + bool CondDataPresent = false; // Flag set when conductivity data is available - int NumCondTempPts = 0; // Number of temperature points for conductivity + int NumCondTempPoints = 0; // Number of temperature points for conductivity Real64 CondLowTempValue = 0.0; // Low Temperature Value for Cond (>0.0) Real64 CondHighTempValue = 0.0; // High Temperature Value for Cond (max in tables) int CondLowTempIndex = 0; // Low Temperature Min Index for Cond (>0.0) int CondHighTempIndex = 0; // High Temperature Max Index for Cond (>0.0) Array1D CondTemps; // Temperatures for conductivity of glycol Array1D CondValues; // conductivity values (W/m-K) - + Array1D CondTempRatios; // Speed optimization + bool ViscDataPresent = false; // Flag set when viscosity data is available - int NumViscTempPts = 0; // Number of temperature points for viscosity + int NumViscTempPoints = 0; // Number of temperature points for viscosity Real64 ViscLowTempValue = 0.0; // Low Temperature Value for Visc (>0.0) Real64 ViscHighTempValue = 0.0; // High Temperature Value for Visc (max in tables) int ViscLowTempIndex = 0; // Low Temperature Min Index for Visc (>0.0) int ViscHighTempIndex = 0; // High Temperature Max Index for Visc (>0.0) Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscValues; // viscosity values (mPa-s) - + Array1D ViscTempRatios; + std::array errors; #ifdef EP_cache_GlycolSpecificHeat @@ -506,48 +500,12 @@ namespace FluidProperties { std::string_view CalledFrom // routine this function was called from (error messages) ); - void GetInterpValue_error(EnergyPlusData &state); - - inline Real64 GetInterpValue(EnergyPlusData &state, - Real64 const Tact, // actual temperature at which we want the property of interest + inline Real64 GetInterpValue(Real64 const Tact, // actual temperature at which we want the property of interest Real64 const Tlo, // temperature below Tact for which we have property data Real64 const Thi, // temperature above Tact for which we have property data Real64 const Xlo, // value of property at Tlo Real64 const Xhi // value of property at Thi ) - { - // FUNCTION INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN June 2004 - // MODIFIED N/A - // RE-ENGINEERED N/A - - // PURPOSE OF THIS FUNCTION: - // This subroutine does a simple linear interpolation. - - // METHODOLOGY EMPLOYED: - // No mysteries here...just plain-old linear interpolation. - - // REFERENCES: - // Any basic engineering mathematic text. - - // SUBROUTINE PARAMETER DEFINITIONS: - Real64 constexpr TempToler(0.001); // Some reasonable value for comparisons - - if (std::abs(Thi - Tlo) > TempToler) { - return Xhi - (((Thi - Tact) / (Thi - Tlo)) * (Xhi - Xlo)); - } else { - GetInterpValue_error(state); - return 0.0; - } - } - - inline Real64 GetInterpValue_fast(Real64 const Tact, // actual temperature at which we want the property of interest - Real64 const Tlo, // temperature below Tact for which we have property data - Real64 const Thi, // temperature above Tact for which we have property data - Real64 const Xlo, // value of property at Tlo - Real64 const Xhi // value of property at Thi - ) { return Xhi - (((Thi - Tact) / (Thi - Tlo)) * (Xhi - Xlo)); } @@ -555,9 +513,12 @@ namespace FluidProperties { int GetRefrigNum(EnergyPlusData &state, std::string_view name); RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view name); + int GetGlycolRawNum(EnergyPlusData &state, std::string_view name); + GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view name); + int GetGlycolNum(EnergyPlusData &state, std::string_view name); GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view name); - + std::string GetGlycolNameByIndex(EnergyPlusData &state, int Idx); // carries in substance index int FindArrayIndex(Real64 Value, // Value to be placed/found within the array of values @@ -581,7 +542,7 @@ namespace FluidProperties { int UpperBound // Valid values upper bound (set by calling program) ); - int CheckFluidPropertyName(EnergyPlusData &state, + bool CheckFluidPropertyName(EnergyPlusData &state, std::string const &NameToCheck); // Name from input(?) to be checked against valid FluidPropertyNames void ReportOrphanFluids(EnergyPlusData &state); @@ -624,17 +585,14 @@ namespace FluidProperties { struct FluidData : BaseGlobalStruct { - - int NumOfRefrigerants = 0; // Total number of refrigerants input by user - int NumOfGlycols = 0; // Total number of glycols input by user bool DebugReportGlycols = false; bool DebugReportRefrigerants = false; int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called int RefrigErrorLimitTest = 1; // how many times error is printed with details before recurring called - Array1D RefrigData; - Array1D GlyRawData; - Array1D GlycolData; + Array1D refrigs; + Array1D glycolsRaw; + Array1D glycols; std::array glycolErrorLimits = {0, 0, 0, 0, 0, 0, 0, 0}; @@ -656,6 +614,11 @@ struct FluidData : BaseGlobalStruct void clear_state() override { + + for (int i = 1; i <= refrigs.isize(); ++i) delete refrigs(i); + for (int i = 1; i <= glycolsRaw.isize(); ++i) delete refrigs(i); + for (int i = 1; i <= glycols.isize(); ++i) delete refrigs(i); + new (this) FluidData(); } }; diff --git a/src/EnergyPlus/NodeInputManager.cc b/src/EnergyPlus/NodeInputManager.cc index 5f67b91ad73..51032f8fe45 100644 --- a/src/EnergyPlus/NodeInputManager.cc +++ b/src/EnergyPlus/NodeInputManager.cc @@ -1143,7 +1143,7 @@ void CalcMoreNodeInfo(EnergyPlusData &state) } else if (state.dataLoopNodes->Node(iNode).FluidType == DataLoopNode::NodeFluidType::Water) { if (!((state.dataLoopNodes->Node(iNode).FluidIndex > 0) && - (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluidProps->NumOfGlycols))) { + (state.dataLoopNodes->Node(iNode).FluidIndex <= state.dataFluidProps->glycols.isize()))) { rho = RhoWaterStdInit; rhoStd = RhoWaterStdInit; Cp = CPCW(state.dataLoopNodes->Node(iNode).Temp); diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index afb905ad6e3..1715d43cb75 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -717,7 +717,7 @@ namespace OutdoorAirUnit { thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0; // below: no extra error needed if steam properties not in input // file because getting the steam coil will have done that. - thisOutAirUnit.OAEquip(CompNum).FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); + thisOutAirUnit.OAEquip(CompNum).FluidIndex = FluidProperties::GetRefrigNum(state, "STEAM"); break; } case CompType::WaterCoil_DetailedCool: { diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index a763942ed5e..b293743f045 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -323,7 +323,7 @@ void GetPIUs(EnergyPlusData &state) } case HtgCoilType::SteamAirHeating: { thisPIU.HCoil_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating; - thisPIU.HCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); + thisPIU.HCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "STEAM"); if (thisPIU.HCoil_FluidIndex == 0) { ShowSevereError(state, format("{} Steam Properties for {} not found.", RoutineName, thisPIU.Name)); if (SteamMessageNeeded) { diff --git a/src/EnergyPlus/SteamBaseboardRadiator.cc b/src/EnergyPlus/SteamBaseboardRadiator.cc index 089fd60f2db..aa6203b7481 100644 --- a/src/EnergyPlus/SteamBaseboardRadiator.cc +++ b/src/EnergyPlus/SteamBaseboardRadiator.cc @@ -779,7 +779,7 @@ namespace SteamBaseboardRadiator { } if (state.dataSteamBaseboardRadiator->SteamIndex == 0 && BaseboardNum == 1) { - state.dataSteamBaseboardRadiator->SteamIndex = FluidProperties::GetRefrigNum(state, "Steam"); + state.dataSteamBaseboardRadiator->SteamIndex = FluidProperties::GetRefrigNum(state, "STEAM"); if (state.dataSteamBaseboardRadiator->SteamIndex == 0) { ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, state.dataIPShortCut->cAlphaArgs(1))); if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); diff --git a/src/EnergyPlus/SteamCoils.cc b/src/EnergyPlus/SteamCoils.cc index 1a08fa67b76..0067af18d0a 100644 --- a/src/EnergyPlus/SteamCoils.cc +++ b/src/EnergyPlus/SteamCoils.cc @@ -370,7 +370,7 @@ namespace SteamCoils { TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(5), AlphArray(6), "Air Nodes"); if (state.dataSteamCoils->SteamIndex == 0 && CoilNum == 1) { - state.dataSteamCoils->SteamIndex = FluidProperties::GetRefrigNum(state, "Steam"); + state.dataSteamCoils->SteamIndex = FluidProperties::GetRefrigNum(state, "STEAM"); if (state.dataSteamCoils->SteamIndex == 0) { ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, AlphArray(1))); ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index b9527e64936..3b10ee75a21 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -1050,7 +1050,7 @@ namespace VentilatedSlab { } case HeatingCoilType::Steam: { ventSlab.heatingCoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating; - ventSlab.heatingCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "Steam"); + ventSlab.heatingCoil_FluidIndex = FluidProperties::GetRefrigNum(state, "STEAM"); if (ventSlab.heatingCoil_FluidIndex == 0) { ShowSevereError(state, format("{}=\"{}Steam Properties not found.", CurrentModuleObject, ventSlab.Name)); if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file."); diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc index ed764ee68ce..f3da433eec1 100644 --- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc +++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc @@ -360,7 +360,6 @@ bool EnergyPlusFixture::process_idf(std::string_view const idf_snippet, bool use inputProcessor->initializeMaps(); SimulationManager::PostIPProcessing(*state); - FluidProperties::GetFluidPropertiesData(*state); state->init_state(*state); if (state->dataSQLiteProcedures->sqlite) { diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index 39f05583cc0..f26b98a19f8 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -2356,12 +2356,12 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_VRFOU_Compressor) Curve::GetCurveInput(*state); // read curves // test consecutive call to fluid properties getInput FluidProperties::GetFluidPropertiesData(*state); // read refrigerant properties - EXPECT_EQ(2, state->dataFluidProps->NumOfRefrigerants); - EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + EXPECT_EQ(2, state->dataFluidProps->refrigs.isize()); + EXPECT_EQ(1, state->dataFluidProps->glycols.isize()); FluidProperties::GetFluidPropertiesData(*state); // should never happen but if it does it's safe - EXPECT_EQ(2, state->dataFluidProps->NumOfRefrigerants); - EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + EXPECT_EQ(2, state->dataFluidProps->refrigs.isize()); + EXPECT_EQ(1, state->dataFluidProps->glycols.isize()); // set up ZoneEquipConfig data state->dataGlobal->NumOfZones = 1; diff --git a/tst/EnergyPlus/unit/PlantUtilities.unit.cc b/tst/EnergyPlus/unit/PlantUtilities.unit.cc index 985eab7d687..edb6bfccb56 100644 --- a/tst/EnergyPlus/unit/PlantUtilities.unit.cc +++ b/tst/EnergyPlus/unit/PlantUtilities.unit.cc @@ -92,12 +92,12 @@ TEST_F(EnergyPlusFixture, TestRegulateCondenserCompFlowReqOp) { // test consecutive call to fluid properties getInput FluidProperties::GetFluidPropertiesData(*state); - EXPECT_EQ(1, state->dataFluidProps->NumOfRefrigerants); - EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + EXPECT_EQ(1, state->dataFluidProps->refrigs.isize()); + EXPECT_EQ(1, state->dataFluidProps->glycols.isize()); FluidProperties::GetFluidPropertiesData(*state); // should never happen but if it does it's safe - EXPECT_EQ(1, state->dataFluidProps->NumOfRefrigerants); - EXPECT_EQ(1, state->dataFluidProps->NumOfGlycols); + EXPECT_EQ(1, state->dataFluidProps->refrigs.isize()); + EXPECT_EQ(1, state->dataFluidProps->glycols.isize()); // This test captures all code paths through the RegulateCondenserCompFlowReqOp function // We only need a single component to check here diff --git a/tst/EnergyPlus/unit/SetPointManager.unit.cc b/tst/EnergyPlus/unit/SetPointManager.unit.cc index 0ba7a3af76f..b2786517313 100644 --- a/tst/EnergyPlus/unit/SetPointManager.unit.cc +++ b/tst/EnergyPlus/unit/SetPointManager.unit.cc @@ -189,10 +189,10 @@ TEST_F(EnergyPlusFixture, SetPointManager_DefineReturnWaterChWSetPointManager_Fl ASSERT_TRUE(process_idf(idf_objects)); - EXPECT_EQ(2, state->dataFluidProps->NumOfGlycols); - const auto &thisGlycol = state->dataFluidProps->GlycolData(2); - EXPECT_EQ("ETHYLENEGLYCOL40PERCENT", thisGlycol.Name); - EXPECT_EQ("ETHYLENEGLYCOL", thisGlycol.GlycolName); + EXPECT_EQ(2, state->dataFluidProps->glycols.isize()); + const auto *glycol = state->dataFluidProps->glycols(2); + EXPECT_EQ("ETHYLENEGLYCOL40PERCENT", glycol->Name); + EXPECT_EQ("ETHYLENEGLYCOL", glycol->GlycolName); // Set up the required plant loop data state->dataPlnt->TotNumLoops = 1; diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index ca3e396a734..741c2a7d0dd 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -384,7 +384,6 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = state->dataWaterCoils->WaterCoil(CoilNum).Name; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; createCoilSelectionReportObj(*state); WaterCoils::SizeWaterCoil(*state, CoilNum); diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 8a6b6d9f3b3..7dade685a33 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -229,7 +229,6 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; createCoilSelectionReportObj(*state); SizeWaterCoil(*state, CoilNum); @@ -465,7 +464,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -622,7 +620,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) state->dataSize->CurSysNum = 1; state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -783,7 +780,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; @@ -904,7 +900,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1023,7 +1018,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1149,7 +1143,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath) state->dataSize->PlantSizData(1).ExitTemp = 5.7; state->dataSize->PlantSizData(1).DeltaT = 5.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; OutputReportPredefined::SetPredefinedTables(*state); @@ -1306,7 +1299,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) state->dataSize->PlantSizData(1).DeltaT = 10.0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; // run water coil sizing createCoilSelectionReportObj(*state); @@ -1403,7 +1395,6 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) state->dataSize->CurOASysNum = 0; state->dataSize->DataWaterLoopNum = 1; - state->dataFluidProps->NumOfGlycols = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc index bb679982bd0..1051cfd24d1 100644 --- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc +++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc @@ -771,7 +771,7 @@ TEST_F(EnergyPlusFixture, HPWHEnergyBalance) state->dataWaterThermalTanks->mdotAir = 0.0993699992873531; int GlycolIndex = 0; - const Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, FluidProperties::Water, Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); + const Real64 Cp = FluidProperties::GetSpecificHeatGlycol(*state, "WATER", Tank.TankTemp, GlycolIndex, "HPWHEnergyBalance"); Tank.CalcHeatPumpWaterHeater(*state, false); diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc index 006dcb4754e..53008112825 100644 --- a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc @@ -137,63 +137,64 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) ASSERT_TRUE(process_idf(idf_objects)); - state->dataFluidProps->RefrigData.allocate(1); - auto &refrig = state->dataFluidProps->RefrigData(1); - refrig.Name = "R22"; - refrig.Num = 1; - refrig.PsLowTempIndex = 1; - refrig.PsHighTempIndex = 2; - refrig.PsTemps.allocate(2); - refrig.PsTemps(1) = -157.42; - refrig.PsTemps(2) = 96.145; - refrig.PsValues.allocate(2); - refrig.PsValues(1) = 0.3795; - refrig.PsValues(2) = 4990000.0; - - refrig.HfLowTempIndex = 1; - refrig.HfHighTempIndex = 2; - refrig.PsLowPresIndex = 1; - refrig.PsHighPresIndex = 2; - refrig.HTemps.allocate(2); - refrig.HfValues.allocate(2); - refrig.HfgValues.allocate(2); - - refrig.HTemps(1) = -157.42; - refrig.HTemps(2) = 96.145; - refrig.HfValues(1) = 29600.0; - refrig.HfValues(2) = 366900.0; - refrig.HfgValues(1) = 332700.0; - refrig.HfgValues(2) = 366900.0; - refrig.NumSuperTempPts = 2; - refrig.NumSuperPressPts = 2; - refrig.SHTemps.allocate(2); - refrig.SHPress.allocate(2); - refrig.SHTemps(1) = -157.15; - refrig.SHTemps(2) = 152.85; - refrig.SHPress(1) = 0.4043; - refrig.SHPress(2) = 16500000.0; - refrig.HshValues.allocate(2, 2); - refrig.HshValues(1, 1) = 332800.0; - refrig.HshValues(1, 2) = 537000.0; - refrig.HshValues(2, 1) = 332800.0; - refrig.HshValues(2, 2) = 537000.0; - refrig.RhoshValues.allocate(2, 2); - refrig.RhoshValues(1, 1) = 0.00003625; - refrig.RhoshValues(1, 2) = 0.0; - refrig.RhoshValues(2, 1) = 0.00003625; - refrig.RhoshValues(2, 2) = 0.0; - - refrig.RhofLowTempIndex = 1; - refrig.RhofHighTempIndex = 2; - refrig.RhoTemps.allocate(2); - refrig.RhoTemps(1) = -157.42; - refrig.RhoTemps(2) = 96.145; - refrig.RhofValues.allocate(2); - refrig.RhofValues(1) = 1721.0; - refrig.RhofValues(2) = 523.8; - refrig.RhofgValues.allocate(2); - refrig.RhofgValues(1) = 0.341; - refrig.RhofgValues(2) = 523.8; + auto *refrig = new FluidProperties::RefrigProps; + refrig->Name = "R22"; + state->dataFluidProps->refrigs.push_back(refrig); + refrig->Num = state->dataFluidProps->refrigs.isize(); + + refrig->PsLowTempIndex = 1; + refrig->PsHighTempIndex = 2; + refrig->PsTemps.allocate(2); + refrig->PsTemps(1) = -157.42; + refrig->PsTemps(2) = 96.145; + refrig->PsValues.allocate(2); + refrig->PsValues(1) = 0.3795; + refrig->PsValues(2) = 4990000.0; + + refrig->HfLowTempIndex = 1; + refrig->HfHighTempIndex = 2; + refrig->PsLowPresIndex = 1; + refrig->PsHighPresIndex = 2; + refrig->HTemps.allocate(2); + refrig->HfValues.allocate(2); + refrig->HfgValues.allocate(2); + + refrig->HTemps(1) = -157.42; + refrig->HTemps(2) = 96.145; + refrig->HfValues(1) = 29600.0; + refrig->HfValues(2) = 366900.0; + refrig->HfgValues(1) = 332700.0; + refrig->HfgValues(2) = 366900.0; + refrig->NumSupTempPoints = 2; + refrig->NumSupPressPoints = 2; + refrig->SupTemps.allocate(2); + refrig->SupPress.allocate(2); + refrig->SupTemps(1) = -157.15; + refrig->SupTemps(2) = 152.85; + refrig->SupPress(1) = 0.4043; + refrig->SupPress(2) = 16500000.0; + refrig->HshValues.allocate(2, 2); + refrig->HshValues(1, 1) = 332800.0; + refrig->HshValues(1, 2) = 537000.0; + refrig->HshValues(2, 1) = 332800.0; + refrig->HshValues(2, 2) = 537000.0; + refrig->RhoshValues.allocate(2, 2); + refrig->RhoshValues(1, 1) = 0.00003625; + refrig->RhoshValues(1, 2) = 0.0; + refrig->RhoshValues(2, 1) = 0.00003625; + refrig->RhoshValues(2, 2) = 0.0; + + refrig->RhofLowTempIndex = 1; + refrig->RhofHighTempIndex = 2; + refrig->RhoTemps.allocate(2); + refrig->RhoTemps(1) = -157.42; + refrig->RhoTemps(2) = 96.145; + refrig->RhofValues.allocate(2); + refrig->RhofValues(1) = 1721.0; + refrig->RhofValues(2) = 523.8; + refrig->RhofgValues.allocate(2); + refrig->RhofgValues(1) = 0.341; + refrig->RhofgValues(2) = 523.8; GetWatertoAirHPInput(*state); @@ -308,5 +309,5 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) // clean up state->dataWaterToAirHeatPump->WatertoAirHP.deallocate(); - state->dataFluidProps->RefrigData.deallocate(); + delete state->dataFluidProps->refrigs(1); } From bf4b914673ff758d4b73cf6694a98f36cf87f864 Mon Sep 17 00:00:00 2001 From: amirroth Date: Sat, 20 Jul 2024 13:48:27 -0400 Subject: [PATCH 109/115] Fix initialization and API issues --- src/EnergyPlus/FluidProperties.cc | 478 ++++++------------ src/EnergyPlus/FluidProperties.hh | 4 +- src/EnergyPlus/SetPointManager.hh | 2 +- src/EnergyPlus/UtilityRoutines.cc | 100 ++++ src/EnergyPlus/UtilityRoutines.hh | 16 + .../ObjexxFCL/src/ObjexxFCL/Array1S.hh | 12 + 6 files changed, 290 insertions(+), 322 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 41b39fbb56f..1d9880145a8 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -673,11 +673,11 @@ namespace FluidProperties { refrig->Num = df->refrigs.isize(); } } else if (Alphas(2) == "GLYCOL") { - if (GetGlycolNum(state, Alphas(1)) == 0) { - auto *glycol = new GlycolProps; - glycol->Name = Alphas(1); - df->glycols.push_back(glycol); - glycol->Num = df->glycols.isize(); + if (GetGlycolRawNum(state, Alphas(1)) == 0) { + auto *glycolRaw = new GlycolRawProps; + glycolRaw->Name = Alphas(1); + df->glycolsRaw.push_back(glycolRaw); + glycolRaw->Num = df->glycolsRaw.isize(); } } else { ShowSevereError(state, format("{}: {}=\"{}\", invalid type", routineName, CurrentModuleObject, Alphas(1))); @@ -1044,8 +1044,10 @@ namespace FluidProperties { continue; } - refrig->SupPress.push_back(Numbers(1)); - ++refrig->NumSupPressPoints; + if (std::find(refrig->SupPress.begin(), refrig->SupPress.end(), Numbers(1)) == refrig->SupPress.end()) { + refrig->SupPress.push_back(Numbers(1)); + ++refrig->NumSupPressPoints; + } } // Sort and allocate pressure point arrays @@ -1116,6 +1118,52 @@ namespace FluidProperties { // be produced. // Propylene and ethylene are available by default + auto *waterRaw = new GlycolRawProps; + waterRaw->Name = "WATER"; + + df->glycolsRaw.push_back(waterRaw); + waterRaw->Num = df->glycolsRaw.isize(); + + waterRaw->CpDataPresent = true; + waterRaw->NumCpConcPoints = 1; + waterRaw->NumCpTempPoints = DefaultNumGlyTemps; + waterRaw->CpTemps.allocate(waterRaw->NumCpTempPoints); + waterRaw->CpTemps = DefaultGlycolTemps; + waterRaw->CpConcs.allocate(waterRaw->NumCpConcPoints); + waterRaw->CpConcs = 0.0; + waterRaw->CpValues.allocate(waterRaw->NumCpConcPoints, waterRaw->NumCpTempPoints); + waterRaw->CpValues(1, {1, waterRaw->NumCpTempPoints}) = DefaultWaterCpData; + + waterRaw->RhoDataPresent = true; + waterRaw->NumRhoConcPoints = 1; + waterRaw->NumRhoTempPoints = DefaultNumGlyTemps; + waterRaw->RhoTemps.allocate(waterRaw->NumRhoTempPoints); + waterRaw->RhoTemps = DefaultGlycolTemps; + waterRaw->RhoConcs.allocate(waterRaw->NumRhoConcPoints); + waterRaw->RhoConcs = 0.0; + waterRaw->RhoValues.allocate(waterRaw->NumRhoConcPoints, waterRaw->NumRhoTempPoints); + waterRaw->RhoValues(1, {1, waterRaw->NumRhoTempPoints}) = DefaultWaterRhoData; + + waterRaw->CondDataPresent = true; + waterRaw->NumCondConcPoints = 1; + waterRaw->NumCondTempPoints = DefaultNumGlyTemps; + waterRaw->CondTemps.allocate(waterRaw->NumCondTempPoints); + waterRaw->CondTemps = DefaultGlycolTemps; + waterRaw->CondConcs.allocate(waterRaw->NumCondConcPoints); + waterRaw->CondConcs = 0.0; + waterRaw->CondValues.allocate(waterRaw->NumCondConcPoints, waterRaw->NumCondTempPoints); + waterRaw->CondValues(1, {1, waterRaw->NumCondTempPoints}) = DefaultWaterCondData; + + waterRaw->ViscDataPresent = true; + waterRaw->NumViscConcPoints = 1; + waterRaw->NumViscTempPoints = DefaultNumGlyTemps; + waterRaw->ViscTemps.allocate(waterRaw->NumViscTempPoints); + waterRaw->ViscTemps = DefaultGlycolTemps; + waterRaw->ViscConcs.allocate(waterRaw->NumViscConcPoints); + waterRaw->ViscConcs = 0.0; + waterRaw->ViscValues.allocate(waterRaw->NumViscConcPoints, waterRaw->NumViscTempPoints); + waterRaw->ViscValues(1, {1, waterRaw->NumViscTempPoints}) = DefaultWaterViscData; + auto *ethylene = new GlycolRawProps; ethylene->Name = "ETHYLENEGLYCOL"; df->glycolsRaw.push_back(ethylene); @@ -1126,19 +1174,15 @@ namespace FluidProperties { ethylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat ethylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat - // No ObjexxFCL templates for assigning std::array to Array1S, Probably want to covert these Array1D and 2D to std::vector eventually anyway ethylene->CpTemps.allocate(ethylene->NumCpTempPoints); // Temperatures for specific heat of glycol - for (int i = 1; i <= ethylene->NumCpTempPoints; ++i) - ethylene->CpTemps(i) = DefaultGlycolTemps[i-1]; + ethylene->CpTemps = DefaultGlycolTemps; ethylene->CpConcs.allocate(ethylene->NumCpConcPoints); // Concentration for specific heat of glycol - for (int i = 1; i <= ethylene->NumCpConcPoints; ++i) - ethylene->CpConcs(i) = DefaultGlycolConcs[i-1]; + ethylene->CpConcs = DefaultGlycolConcs; ethylene->CpValues.allocate(ethylene->NumCpConcPoints, ethylene->NumCpTempPoints); // Specific heat data values for (int i = 1; i <= ethylene->NumCpConcPoints; ++i) - for (int j = 1; j <= ethylene->NumCpTempPoints; ++j) - ethylene->CpValues(i, j) = DefaultEthGlyCpData[i-1][j-1]; + ethylene->CpValues(i, {1, ethylene->NumCpTempPoints}) = DefaultEthGlyCpData[i-1]; // Density ethylene->RhoDataPresent = true; @@ -1146,17 +1190,14 @@ namespace FluidProperties { ethylene->NumRhoConcPoints = DefaultNumGlyConcs; ethylene->RhoTemps.allocate(ethylene->NumRhoTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= ethylene->NumRhoTempPoints; ++i) - ethylene->RhoTemps(i) = DefaultGlycolTemps[i-1]; + ethylene->RhoTemps = DefaultGlycolTemps; ethylene->RhoConcs.allocate(ethylene->NumRhoConcPoints); // Concentration for density of glycol - for (int i = 1; i <= ethylene->NumRhoConcPoints; ++i) - ethylene->RhoConcs(i) = DefaultGlycolConcs[i-1]; + ethylene->RhoConcs = DefaultGlycolConcs; ethylene->RhoValues.allocate(ethylene->NumRhoConcPoints, ethylene->NumRhoTempPoints); // Density data values for (int i = 1; i <= ethylene->NumRhoConcPoints; ++i) - for (int j = 1; j <= ethylene->NumRhoTempPoints; ++j) - ethylene->RhoValues(i, j) = DefaultEthGlyRhoData[i-1][j-1]; + ethylene->RhoValues(i, {1, ethylene->NumRhoTempPoints}) = DefaultEthGlyRhoData[i-1]; // Conductivity ethylene->CondDataPresent = true; @@ -1164,17 +1205,14 @@ namespace FluidProperties { ethylene->NumCondConcPoints = DefaultNumGlyConcs; ethylene->CondTemps.allocate(ethylene->NumCondTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= ethylene->NumCondTempPoints; ++i) - ethylene->CondTemps(i) = DefaultGlycolTemps[i-1]; + ethylene->CondTemps = DefaultGlycolTemps; ethylene->CondConcs.allocate(ethylene->NumCondConcPoints); // Concentration for density of glycol - for (int i = 1; i <= ethylene->NumCondConcPoints; ++i) - ethylene->CondConcs(i) = DefaultGlycolConcs[i-1]; + ethylene->CondConcs = DefaultGlycolConcs; ethylene->CondValues.allocate(ethylene->NumCondConcPoints, ethylene->NumCondTempPoints); // Density data values for (int i = 1; i <= ethylene->NumCondConcPoints; ++i) - for (int j = 1; j <= ethylene->NumCondTempPoints; ++j) - ethylene->CondValues(i, j) = DefaultEthGlyCondData[i-1][j-1]; + ethylene->CondValues(i, {1, ethylene->NumCondTempPoints}) = DefaultEthGlyCondData[i-1]; // Viscosity ethylene->ViscDataPresent = true; @@ -1182,17 +1220,14 @@ namespace FluidProperties { ethylene->NumViscConcPoints = DefaultNumGlyConcs; ethylene->ViscTemps.allocate(ethylene->NumViscTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= ethylene->NumViscTempPoints; ++i) - ethylene->ViscTemps(i) = DefaultGlycolTemps[i-1]; + ethylene->ViscTemps = DefaultGlycolTemps; ethylene->ViscConcs.allocate(ethylene->NumViscConcPoints); // Concentration for density of glycol - for (int i = 1; i <= ethylene->NumViscConcPoints; ++i) - ethylene->ViscConcs(i) = DefaultGlycolConcs[i-1]; + ethylene->ViscConcs = DefaultGlycolConcs; ethylene->ViscValues.allocate(ethylene->NumViscConcPoints, ethylene->NumViscTempPoints); // Density data values for (int i = 1; i <= ethylene->NumViscConcPoints; ++i) - for (int j = 1; j <= ethylene->NumViscTempPoints; ++j) - ethylene->ViscValues(i, j) = DefaultEthGlyViscData[i-1][j-1]; + ethylene->ViscValues(i, {1, ethylene->NumViscTempPoints}) = DefaultEthGlyViscData[i-1]; // Propylene auto *propylene = new GlycolRawProps; @@ -1207,17 +1242,14 @@ namespace FluidProperties { // No ObjexxFCL templates for assigning std::array to Array1S, Probably want to covert these Array1D and 2D to std::vector eventually anyway propylene->CpTemps.allocate(propylene->NumCpTempPoints); // Temperatures for specific heat of glycol - for (int i = 1; i <= propylene->NumCpTempPoints; ++i) - propylene->CpTemps(i) = DefaultGlycolTemps[i-1]; + propylene->CpTemps = DefaultGlycolTemps; propylene->CpConcs.allocate(propylene->NumCpConcPoints); // Concentration for specific heat of glycol - for (int i = 1; i <= propylene->NumCpConcPoints; ++i) - propylene->CpConcs(i) = DefaultGlycolConcs[i-1]; + propylene->CpConcs = DefaultGlycolConcs; propylene->CpValues.allocate(propylene->NumCpConcPoints, propylene->NumCpTempPoints); // Specific heat data values for (int i = 1; i <= propylene->NumCpConcPoints; ++i) - for (int j = 1; j <= propylene->NumCpTempPoints; ++j) - propylene->CpValues(i, j) = DefaultPropGlyCpData[i-1][j-1]; + propylene->CpValues(i, {1, propylene->NumCpTempPoints}) = DefaultPropGlyCpData[i-1]; // Density propylene->RhoDataPresent = true; @@ -1225,17 +1257,14 @@ namespace FluidProperties { propylene->NumRhoConcPoints = DefaultNumGlyConcs; propylene->RhoTemps.allocate(propylene->NumRhoTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= propylene->NumRhoTempPoints; ++i) - propylene->RhoTemps(i) = DefaultGlycolTemps[i-1]; + propylene->RhoTemps = DefaultGlycolTemps; propylene->RhoConcs.allocate(propylene->NumRhoConcPoints); // Concentration for density of glycol - for (int i = 1; i <= propylene->NumRhoConcPoints; ++i) - propylene->RhoConcs(i) = DefaultGlycolConcs[i-1]; + propylene->RhoConcs = DefaultGlycolConcs; propylene->RhoValues.allocate(propylene->NumRhoConcPoints, propylene->NumRhoTempPoints); // Density data values for (int i = 1; i <= propylene->NumRhoConcPoints; ++i) - for (int j = 1; j <= propylene->NumRhoTempPoints; ++j) - propylene->RhoValues(i, j) = DefaultPropGlyRhoData[i-1][j-1]; + propylene->RhoValues(i, {1, propylene->NumRhoTempPoints}) = DefaultPropGlyRhoData[i-1]; // Conductivity propylene->CondDataPresent = true; @@ -1243,17 +1272,14 @@ namespace FluidProperties { propylene->NumCondConcPoints = DefaultNumGlyConcs; propylene->CondTemps.allocate(propylene->NumCondTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= propylene->NumCondTempPoints; ++i) - propylene->CondTemps(i) = DefaultGlycolTemps[i-1]; + propylene->CondTemps = DefaultGlycolTemps; propylene->CondConcs.allocate(propylene->NumCondConcPoints); // Concentration for density of glycol - for (int i = 1; i <= propylene->NumCondConcPoints; ++i) - propylene->CondConcs(i) = DefaultGlycolConcs[i-1]; + propylene->CondConcs = DefaultGlycolConcs; propylene->CondValues.allocate(propylene->NumCondConcPoints, propylene->NumCondTempPoints); // Density data values for (int i = 1; i <= propylene->NumCondConcPoints; ++i) - for (int j = 1; j <= propylene->NumCondTempPoints; ++j) - propylene->CondValues(i, j) = DefaultPropGlyCondData[i-1][j-1]; + propylene->CondValues(i, {1, propylene->NumCondTempPoints}) = DefaultPropGlyCondData[i-1]; // Viscosity propylene->ViscDataPresent = true; @@ -1261,17 +1287,14 @@ namespace FluidProperties { propylene->NumViscConcPoints = DefaultNumGlyConcs; propylene->ViscTemps.allocate(propylene->NumViscTempPoints); // Temperatures for density of glycol - for (int i = 1; i <= propylene->NumViscTempPoints; ++i) - propylene->ViscTemps(i) = DefaultGlycolTemps[i-1]; + propylene->ViscTemps = DefaultGlycolTemps; propylene->ViscConcs.allocate(propylene->NumViscConcPoints); // Concentration for density of glycol - for (int i = 1; i <= propylene->NumViscConcPoints; ++i) - propylene->ViscConcs(i) = DefaultGlycolConcs[i-1]; + propylene->ViscConcs = DefaultGlycolConcs; propylene->ViscValues.allocate(propylene->NumViscConcPoints, propylene->NumViscTempPoints); // Density data values for (int i = 1; i <= propylene->NumViscConcPoints; ++i) - for (int j = 1; j <= propylene->NumViscTempPoints; ++j) - propylene->ViscValues(i, j) = DefaultPropGlyViscData[i-1][j-1]; + propylene->ViscValues(i, {1, propylene->NumViscTempPoints}) = DefaultPropGlyViscData[i-1]; CurrentModuleObject = "FluidProperties:Concentration"; @@ -1322,9 +1345,12 @@ namespace FluidProperties { continue; } glycolRaw->CpTempArrayName = Alphas(3); - - glycolRaw->CpConcs.push_back(Numbers(1)); - ++glycolRaw->NumCpConcPoints; + + if (std::find(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end(), Numbers(1)) == glycolRaw->CpConcs.end()) { + glycolRaw->CpConcs.push_back(Numbers(1)); + ++glycolRaw->NumCpConcPoints; + } + glycolRaw->CpDataPresent = true; } else if (Alphas(2) == "DENSITY") { if (glycolRaw->RhoTempArrayName != "" && glycolRaw->RhoTempArrayName != Alphas(3)) { @@ -1334,10 +1360,13 @@ namespace FluidProperties { ErrorsFound = true; continue; } - glycolRaw->CpTempArrayName = Alphas(3); + glycolRaw->RhoTempArrayName = Alphas(3); - glycolRaw->RhoConcs.push_back(Numbers(1)); - ++glycolRaw->NumRhoConcPoints; + if (std::find(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end(), Numbers(1)) == glycolRaw->RhoConcs.end()) { + glycolRaw->RhoConcs.push_back(Numbers(1)); + ++glycolRaw->NumRhoConcPoints; + } + glycolRaw->RhoDataPresent = true; } else if (Alphas(2) == "CONDUCTIVITY") { if (glycolRaw->CondTempArrayName != "" && glycolRaw->CondTempArrayName != Alphas(3)) { @@ -1349,8 +1378,11 @@ namespace FluidProperties { } glycolRaw->CondTempArrayName = Alphas(3); - glycolRaw->CondConcs.push_back(Numbers(1)); - ++glycolRaw->NumCondConcPoints; + if (std::find(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end(), Numbers(1)) == glycolRaw->CondConcs.end()) { + glycolRaw->CondConcs.push_back(Numbers(1)); + ++glycolRaw->NumCondConcPoints; + } + glycolRaw->CondDataPresent = true; } else if (Alphas(2) == "VISCOSITY") { if (glycolRaw->ViscTempArrayName != "" && glycolRaw->ViscTempArrayName != Alphas(3)) { @@ -1362,8 +1394,11 @@ namespace FluidProperties { } glycolRaw->ViscTempArrayName = Alphas(3); - glycolRaw->ViscConcs.push_back(Numbers(1)); - ++glycolRaw->NumViscConcPoints; + if (std::find(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end(), Numbers(1)) == glycolRaw->ViscConcs.end()) { + glycolRaw->ViscConcs.push_back(Numbers(1)); + ++glycolRaw->NumViscConcPoints; + } + glycolRaw->ViscDataPresent = true; } else { ShowSevereInvalidKey(state, eoh, cAlphaFields(2), Alphas(2), @@ -1375,43 +1410,49 @@ namespace FluidProperties { // Allocate and sort temp point/conc point arrays for (auto *glycolRaw : df->glycolsRaw) { - if (glycolRaw->Name == "ETHYLENEGLYCOL" || glycolRaw->Name == "PROPYLENEGLYCOL") continue; + if (!glycolRaw->CpTempArrayName.empty()) { + int cpTempArrayNum = Util::FindItemInList(glycolRaw->CpTempArrayName, FluidTemps); + auto &cpTempArray = FluidTemps(cpTempArrayNum); + glycolRaw->NumCpTempPoints = cpTempArray.NumOfTemps; + glycolRaw->CpTemps.allocate(glycolRaw->NumCpTempPoints); + glycolRaw->CpTemps = cpTempArray.Temps; - int cpTempArrayNum = Util::FindItemInList(glycolRaw->CpTempArrayName, FluidTemps); - auto &cpTempArray = FluidTemps(cpTempArrayNum); - glycolRaw->NumCpTempPoints = cpTempArray.NumOfTemps; - glycolRaw->CpTemps.allocate(glycolRaw->NumCpTempPoints); - glycolRaw->CpTemps = cpTempArray.Temps; - - glycolRaw->CpValues.allocate(glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints); - std::sort(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end()); - - int rhoTempArrayNum = Util::FindItemInList(glycolRaw->RhoTempArrayName, FluidTemps); - auto &rhoTempArray = FluidTemps(rhoTempArrayNum); - glycolRaw->NumRhoTempPoints = rhoTempArray.NumOfTemps; - glycolRaw->RhoTemps.allocate(glycolRaw->NumRhoTempPoints); - glycolRaw->RhoTemps = rhoTempArray.Temps; - - glycolRaw->RhoValues.allocate(glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints); - std::sort(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end()); - - int condTempArrayNum = Util::FindItemInList(glycolRaw->CondTempArrayName, FluidTemps); - auto &condTempArray = FluidTemps(condTempArrayNum); - glycolRaw->NumCondTempPoints = condTempArray.NumOfTemps; - glycolRaw->CondTemps.allocate(glycolRaw->NumCondTempPoints); - glycolRaw->CondTemps = condTempArray.Temps; - - glycolRaw->CondValues.allocate(glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints); - std::sort(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end()); - - int viscTempArrayNum = Util::FindItemInList(glycolRaw->ViscTempArrayName, FluidTemps); - auto &viscTempArray = FluidTemps(viscTempArrayNum); - glycolRaw->NumViscTempPoints = viscTempArray.NumOfTemps; - glycolRaw->ViscTemps.allocate(glycolRaw->NumViscTempPoints); - glycolRaw->ViscTemps = viscTempArray.Temps; + glycolRaw->CpValues.allocate(glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints); + std::sort(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end()); + } - glycolRaw->ViscValues.allocate(glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints); - std::sort(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end()); + if (!glycolRaw->RhoTempArrayName.empty()) { + int rhoTempArrayNum = Util::FindItemInList(glycolRaw->RhoTempArrayName, FluidTemps); + auto &rhoTempArray = FluidTemps(rhoTempArrayNum); + glycolRaw->NumRhoTempPoints = rhoTempArray.NumOfTemps; + glycolRaw->RhoTemps.allocate(glycolRaw->NumRhoTempPoints); + glycolRaw->RhoTemps = rhoTempArray.Temps; + + glycolRaw->RhoValues.allocate(glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints); + std::sort(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end()); + } + + if (!glycolRaw->CondTempArrayName.empty()) { + int condTempArrayNum = Util::FindItemInList(glycolRaw->CondTempArrayName, FluidTemps); + auto &condTempArray = FluidTemps(condTempArrayNum); + glycolRaw->NumCondTempPoints = condTempArray.NumOfTemps; + glycolRaw->CondTemps.allocate(glycolRaw->NumCondTempPoints); + glycolRaw->CondTemps = condTempArray.Temps; + + glycolRaw->CondValues.allocate(glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints); + std::sort(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end()); + } + + if (!glycolRaw->ViscTempArrayName.empty()) { + int viscTempArrayNum = Util::FindItemInList(glycolRaw->ViscTempArrayName, FluidTemps); + auto &viscTempArray = FluidTemps(viscTempArrayNum); + glycolRaw->NumViscTempPoints = viscTempArray.NumOfTemps; + glycolRaw->ViscTemps.allocate(glycolRaw->NumViscTempPoints); + glycolRaw->ViscTemps = viscTempArray.Temps; + + glycolRaw->ViscValues.allocate(glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints); + std::sort(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end()); + } } // Finally, get the specific heat and concentration values from the user input @@ -1523,7 +1564,7 @@ namespace FluidProperties { auto *water = new GlycolProps; water->Name = "WATER"; - water->GlycolName = ""; + water->GlycolName = "WATER"; water->used = true; // mark Water as always used df->glycols.push_back(water); @@ -1544,7 +1585,6 @@ namespace FluidProperties { water->RhoValues.allocate(water->NumRhoTempPoints); water->CondTemps.allocate(water->NumCondTempPoints); water->CondValues.allocate(water->NumCondTempPoints); - water->CondTempRatios.allocate(water->NumCondTempPoints); water->ViscTemps.allocate(water->NumViscTempPoints); water->ViscValues.allocate(water->NumViscTempPoints); water->CpTemps = DefaultGlycolTemps; @@ -2695,9 +2735,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatTemp].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -2711,17 +2748,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Simon Rees - // DATE WRITTEN 24 May 2002 - - // PURPOSE OF THIS FUNCTION: - // This finds the saturation pressure for given temperature. - - // METHODOLOGY EMPLOYED: - // Calls FindArrayIndex to find indices either side of requested temperature - // and linearly interpolates the corresponding saturation pressure values. + // Wrapper for RefrigProps::getSatPressure() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -2804,9 +2831,6 @@ namespace FluidProperties { format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), this->errors[(int)RefrigError::SatPress].index, Pressure, - Pressure, - _, - "{Pa}", "{Pa}"); } return ReturnValue; @@ -2819,17 +2843,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Simon Rees - // DATE WRITTEN 24 May 2002 - - // PURPOSE OF THIS FUNCTION: - // This finds the saturation temperature for given pressure. - - // METHODOLOGY EMPLOYED: - // Calls FindArrayIndex to find indices either side of requested pressure - // and linearly interpolates the corresponding saturation temperature values. + // Wrapper for RefrigProps::getSatTemperature() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -2879,22 +2893,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Mike Turner - // DATE WRITTEN 10 December 99 - // MODIFIED Rick Strand (April 2000, May 2000) - // Simon Rees (May 2002) - - // PURPOSE OF THIS FUNCTION: - // This finds enthalpy for given temperature and a quality under the vapor dome. - // This fucntion is only called with a valid refrigerant and quality between 0 and 1. - - // METHODOLOGY EMPLOYED: - // Calls GetInterpolatedSatProp to linearly interpolate between the saturated - // liquid and vapour enthalpies according to the given quality. - - // FUNCTION LOCAL VARIABLE DECLARATIONS: + // Wrapper for RefrigProps::getSatEnthalpy() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3005,9 +3004,6 @@ namespace FluidProperties { format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), this->errors[(int)RefrigError::SatTempDensity].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } return ReturnValue; @@ -3021,21 +3017,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Mike Turner - // DATE WRITTEN 10 December 99 - // MODIFIED Rick Strand (April 2000, May 2000) - // Simon Rees (May 2002); Kenneth Tang (Jan 2004) - - // PURPOSE OF THIS SUBROUTINE: - // This finds density for given temperature and a quality under the vapor dome. - // This function is only called with a valid refrigerant and quality between 0 and 1. - - // METHODOLOGY EMPLOYED: - // Calls GetInterpolatedSatProp to linearly interpolate between the saturated - // liquid and vapour densities according to the given quality. - + // Wrapper for RefrigProps::getSatDensity() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3103,20 +3085,7 @@ namespace FluidProperties { ) { - // SUBROUTINE INFORMATION: - // AUTHOR Mike Turner - // DATE WRITTEN 10 December 99 - // MODIFIED Rick Strand (April 2000, May 2000) - // Simon Rees (May 2002) - - // PURPOSE OF THIS SUBROUTINE: - // This finds specific heat for given temperature and a quality under the vapor dome. - // This fucntion is only called with a valid refrigerant and quality between 0 and 1. - - // METHODOLOGY EMPLOYED: - // Calls GetInterpolatedSatProp to linearly interpolate between the saturated - // liquid and vapour specific heats according to the given quality. - + // Wrapper for RefrigProps::getSpecificHeat() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3277,9 +3246,6 @@ namespace FluidProperties { format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, this->Name), this->errors[(int)RefrigError::SatSupEnthalpy].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } return ReturnValue; @@ -3301,9 +3267,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -3322,9 +3285,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupEnthalpyPress].index, Pressure, - Pressure, - _, - "{Pa}", "{Pa}"); } } // end error checking @@ -3340,30 +3300,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Mike Turner - // DATE WRITTEN 10 December 99 - // MODIFIED Rick Strand (April 2000, May 2000) - // MODIFIED Simon Rees (May 2002) - - // PURPOSE OF THIS SUBROUTINE: - // Performs linear interpolation between pressures and temperatures and - // returns enthalpy values. Works only in superheated region. - - // METHODOLOGY EMPLOYED: - // Double linear interpolation is used with enthalpy values at four - // pressure/temperature input points surrounding the given temperature - // and pressure argument values. - // With enthalpy data it is assumed that zero values in the data are in - // the saturated region. Hence, values near the saturation line are - // approximated using the saturation value instead of the zero data value. - // points completely in the saturation region are given the saturation value - // at the given temperature. Points at the upper limits of pressure/temperature - // have the pressure/temperature capped. Warnings are given if the point - // is not clearly in the bounds of the superheated data. - - // FUNCTION PARAMETER DEFINITIONS: + // Wrapper for RefrigProps::getSupHeatEnthalpy() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3412,7 +3349,7 @@ namespace FluidProperties { // FUNCTION PARAMETERS: // the enthalpy calculated from the pressure found - static constexpr std::string_view routineName = "GetSupHeatPressureRefrig"; + static constexpr std::string_view routineName = "RefrigProps::getSupHeatPressure"; auto &df = state.dataFluidProps; @@ -3571,9 +3508,6 @@ namespace FluidProperties { format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), this->errors[(int)RefrigError::SatSupPress].index, ReturnValue, - ReturnValue, - _, - "{Pa}", "{Pa}"); } @@ -3592,9 +3526,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupPressTemp].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -3613,9 +3544,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupPressEnthalpy].index, Enthalpy, - Enthalpy, - _, - "{J}", "{J}"); } } // end error checking @@ -3632,27 +3560,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Rick Strand - // DATE WRITTEN May 2000 - // MODIFIED Simon Rees (May 2002) - - // PURPOSE OF THIS SUBROUTINE: - // Performs linear interpolation between enthalpy and temperatures and - // returns pressure values. Works only in superheated region. - - // METHODOLOGY EMPLOYED: - // Double linear interpolation is used with pressure values at four - // enthalpy/temperature input points surrounding the given temperature - // and enthalpy argument values. - // All enthalpies have to be calculated at the given temperature before a - // search is made for the data adjacent to the given enthalpy. Linear interpolation - // using the enthalpy data is used to interpolate the correspondng pressures. - // Temperatures and enthalpies outside the bounds of the available data are capped - // and warnings given. For enthlpys lower than the saturated vapour value at the - // given temperature result in the saturation pressure being returned (calls to - // GetSatEnthalpy and GetSatPressure are made.) + // Wrapper for RefrigProps::getSupHeatPressure() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3692,7 +3600,7 @@ namespace FluidProperties { // FUNCTION PARAMETERS: // the enthalpy calculated from the pressure found - static constexpr std::string_view routineName = "GetSupHeatTempRefrig"; + static constexpr std::string_view routineName = "RefrigProps::getSupHeatTemp"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature @@ -3777,16 +3685,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - // SUBROUTINE INFORMATION: - // AUTHOR Rongpeng Zhang - // DATE WRITTEN Jan 2016 - - // PURPOSE OF THIS SUBROUTINE: - // Performs iterations to calculate the refrigerant temperature corresponding to the given - // enthalpy and pressure. Works only in superheated region. - - // METHODOLOGY EMPLOYED: - // Perform iterations to identify the temperature by calling GetSupHeatEnthalpyRefrig + // Wrapper for RefrigProps::getSupHeatTemp() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { @@ -3951,9 +3850,6 @@ namespace FluidProperties { format("{}: Refrigerant [{}] saturated at the given conditions **", routineName, this->Name), this->errors[(int)RefrigError::SatSupEnthalpy].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } return saturated_density; @@ -3974,9 +3870,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupDensityTemp].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -3996,9 +3889,6 @@ namespace FluidProperties { routineName, this->Name), this->errors[(int)RefrigError::SatSupDensityPress].index, Pressure, - Pressure, - _, - "{Pa}", "{Pa}"); } // end error checking } @@ -4014,29 +3904,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - - // SUBROUTINE INFORMATION: - // AUTHOR Mike Turner - // DATE WRITTEN 10 December 99 - // MODIFIED Rick Strand (April 2000, May 2000) - // MODIFIED Simon Rees (May 2002) - - // PURPOSE OF THIS SUBROUTINE: - // Performs linear interpolation between pressures and temperatures and - // returns Density values. Works only in superheated region. - - // METHODOLOGY EMPLOYED: - // Double linear interpolation is used with Density values at four - // pressure/temperature input points surrounding the given temperature - // and pressure arguments. - // With Density data it is assumed that zero values in the data are in - // the saturated region. Hence, values near the saturation line are - // approximated using the saturation value instead of the zero data value. - // points completely in the saturation region are given the saturation value - // at the given temperature. Points at the upper limits of pressure/temperature - // have the pressure/temperature capped. Warnings are given if the point - // is not clearly in the bounds of the superheated data. - + // Wrapper for RefrigProps::getSupHeatDensity() auto &df = state.dataFluidProps; if (RefrigIndex == 0) { if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { @@ -4139,9 +4007,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), this->errors[(int)GlycolError::SpecHeatLow].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } return this->CpValues(this->CpLowTempIndex); @@ -4164,9 +4029,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), this->errors[(int)GlycolError::SpecHeatHigh].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } return this->CpValues(this->CpHighTempIndex); @@ -4189,7 +4051,7 @@ namespace FluidProperties { } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] // Is this faster than Interp? - return this->CpValues(end) - (this->CpTemps(end) - Temperature) * this->CpTempRatios(beg); + return GetInterpValue(Temperature, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); } } @@ -4200,7 +4062,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - // This is now just a wrapper for the GlycolProps::getSpecificHeat method + // Wrapper for GlycolProps::getSpecificHeat() auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -4287,9 +4149,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too low) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityLow].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } else { // error == GlycolError::DensityHigh @@ -4307,9 +4166,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too high) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityHigh].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } } @@ -4324,7 +4180,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - // This is now just a wrapper for the GlycolProps::getDensity method + // Wrapper for GlycolProps::getDensity() auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -4415,9 +4271,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), this->errors[(int)error].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -4437,9 +4290,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), this->errors[(int)error].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } } @@ -4454,7 +4304,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - // This is now just a wrapper for the GlycolProps::getConductivity method + // Wrapper for GlycolProps::getConductivity() auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -4546,9 +4396,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too low) for fluid [{}] viscosity **", routineName, this->Name), this->errors[(int)GlycolError::ViscosityLow].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } @@ -4568,9 +4415,6 @@ namespace FluidProperties { format("{}: Temperature out of range (too high) for fluid [{}] viscosity **", routineName, this->Name), this->errors[(int)GlycolError::ViscosityHigh].index, Temperature, - Temperature, - _, - "{C}", "{C}"); } } @@ -4585,8 +4429,7 @@ namespace FluidProperties { std::string_view const CalledFrom // routine this function was called from (error messages) ) { - // This is now just a wrapper for the GlycolProps::getViscosity method - + // Wrapper for GlycolProps::getViscosity() auto &df = state.dataFluidProps; if (GlycolIndex == 0) { @@ -4891,9 +4734,6 @@ namespace FluidProperties { "GetInterpolatedSatProp: Refrigerant temperature for interpolation out of range error", df->TempRangeErrIndexGetInterpolatedSatProp, Temperature, - Temperature, - _, - "{C}", "{C}"); } } diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 5c4862c0d18..37f765807da 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -616,8 +616,8 @@ struct FluidData : BaseGlobalStruct { for (int i = 1; i <= refrigs.isize(); ++i) delete refrigs(i); - for (int i = 1; i <= glycolsRaw.isize(); ++i) delete refrigs(i); - for (int i = 1; i <= glycols.isize(); ++i) delete refrigs(i); + for (int i = 1; i <= glycolsRaw.isize(); ++i) delete glycolsRaw(i); + for (int i = 1; i <= glycols.isize(); ++i) delete glycols(i); new (this) FluidData(); } diff --git a/src/EnergyPlus/SetPointManager.hh b/src/EnergyPlus/SetPointManager.hh index 9eed4a2af28..d3ddac62ea3 100644 --- a/src/EnergyPlus/SetPointManager.hh +++ b/src/EnergyPlus/SetPointManager.hh @@ -554,7 +554,7 @@ struct SetPointManagerData : BaseGlobalStruct InitSetPointManagersOneTimeFlag2 = true; for (int iSPM = 1; iSPM <= (int)spms.size(); ++iSPM) { - delete spms[iSPM]; + delete spms(iSPM); } spms.deallocate(); spmMap.clear(); diff --git a/src/EnergyPlus/UtilityRoutines.cc b/src/EnergyPlus/UtilityRoutines.cc index dd63a95befb..e81815be352 100644 --- a/src/EnergyPlus/UtilityRoutines.cc +++ b/src/EnergyPlus/UtilityRoutines.cc @@ -1231,6 +1231,56 @@ void ShowRecurringSevereErrorAtEnd(EnergyPlusData &state, state, " ** Severe ** " + Message, MsgIndex, ReportMaxOf, ReportMinOf, ReportSumOf, ReportMaxUnits, ReportMinUnits, ReportSumUnits); } +void ShowRecurringSevereErrorAtEnd(EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value +) +{ + + // SUBROUTINE INFORMATION: + // AUTHOR Michael J. Witte + // DATE WRITTEN August 2004 + + // PURPOSE OF THIS SUBROUTINE: + // This subroutine stores a recurring ErrorMessage with a Severe designation + // for output at the end of the simulation with automatic tracking of number + // of occurrences and optional tracking of associated min, max, and sum values + + // METHODOLOGY EMPLOYED: + // Calls StoreRecurringErrorMessage utility routine. + + // Using/Aliasing + using namespace DataStringGlobals; + using namespace DataErrorTracking; + + // INTERFACE BLOCK SPECIFICATIONS + // Use for recurring "severe" error messages shown once at end of simulation + // with count of occurrences and optional max, min, sum + + for (int Loop = 1; Loop <= SearchCounts; ++Loop) { + if (has(Message, MessageSearch[Loop])) { + ++state.dataErrTracking->MatchCounts(Loop); + break; + } + } + bool bNewMessageFound = true; + for (int Loop = 1; Loop <= state.dataErrTracking->NumRecurringErrors; ++Loop) { + if (Util::SameString(state.dataErrTracking->RecurringErrors(Loop).Message, " ** Severe ** " + Message)) { + bNewMessageFound = false; + MsgIndex = Loop; + break; + } + } + if (bNewMessageFound) { + MsgIndex = 0; + } + + ++state.dataErrTracking->TotalSevereErrors; + StoreRecurringErrorMessage(state, " ** Severe ** " + Message, MsgIndex, val, val, _, units, units, ""); +} + void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation int &MsgIndex, // Recurring message index, if zero, next available index is assigned @@ -1286,6 +1336,56 @@ void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, state, " ** Warning ** " + Message, MsgIndex, ReportMaxOf, ReportMinOf, ReportSumOf, ReportMaxUnits, ReportMinUnits, ReportSumUnits); } +void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value +) +{ + + // SUBROUTINE INFORMATION: + // AUTHOR Michael J. Witte + // DATE WRITTEN August 2004 + + // PURPOSE OF THIS SUBROUTINE: + // This subroutine stores a recurring ErrorMessage with a Warning designation + // for output at the end of the simulation with automatic tracking of number + // of occurrences and optional tracking of associated min, max, and sum values + + // METHODOLOGY EMPLOYED: + // Calls StoreRecurringErrorMessage utility routine. + + // Using/Aliasing + using namespace DataStringGlobals; + using namespace DataErrorTracking; + + // INTERFACE BLOCK SPECIFICATIONS + // Use for recurring "warning" error messages shown once at end of simulation + // with count of occurrences and optional max, min, sum + + for (int Loop = 1; Loop <= SearchCounts; ++Loop) { + if (has(Message, MessageSearch[Loop])) { + ++state.dataErrTracking->MatchCounts(Loop); + break; + } + } + bool bNewMessageFound = true; + for (int Loop = 1; Loop <= state.dataErrTracking->NumRecurringErrors; ++Loop) { + if (Util::SameString(state.dataErrTracking->RecurringErrors(Loop).Message, " ** Warning ** " + Message)) { + bNewMessageFound = false; + MsgIndex = Loop; + break; + } + } + if (bNewMessageFound) { + MsgIndex = 0; + } + + ++state.dataErrTracking->TotalWarningErrors; + StoreRecurringErrorMessage(state, " ** Warning ** " + Message, MsgIndex, val, val, _, units, units, ""); +} + void ShowRecurringContinueErrorAtEnd(EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation int &MsgIndex, // Recurring message index, if zero, next available index is assigned diff --git a/src/EnergyPlus/UtilityRoutines.hh b/src/EnergyPlus/UtilityRoutines.hh index 3bfc0caf4f1..9671a9f6e86 100644 --- a/src/EnergyPlus/UtilityRoutines.hh +++ b/src/EnergyPlus/UtilityRoutines.hh @@ -163,6 +163,14 @@ void ShowWarningMessage(EnergyPlusData &state, OptionalOutputFileRef OutUnit1 = {}, OptionalOutputFileRef OutUnit2 = {}); +void ShowRecurringSevereErrorAtEnd( + EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, // Track and report the max of the values passed to this argument + std::string const &units +); + void ShowRecurringSevereErrorAtEnd( EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation @@ -175,6 +183,14 @@ void ShowRecurringSevereErrorAtEnd( std::string const &ReportSumUnits = "" // optional char string (<=15 length) of units for sum value ); +void ShowRecurringWarningErrorAtEnd( + EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value +); + void ShowRecurringWarningErrorAtEnd( EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation diff --git a/third_party/ObjexxFCL/src/ObjexxFCL/Array1S.hh b/third_party/ObjexxFCL/src/ObjexxFCL/Array1S.hh index 03206ce6f9b..d3b7495963e 100644 --- a/third_party/ObjexxFCL/src/ObjexxFCL/Array1S.hh +++ b/third_party/ObjexxFCL/src/ObjexxFCL/Array1S.hh @@ -213,6 +213,18 @@ public: // Assignment: Array public: // Assignment: Value + template< typename U, Size s, class = typename std::enable_if< std::is_assignable< T&, U >::value >::type > + Array1S & + operator =( std::array< U, s > const & a ) + { + assert( size_ == s ); + auto r( a.begin() ); + for ( int i = 1; i <= u_; ++i, ++r ) { + operator ()( i ) = *r; + } + return *this; + } + // Initializer List Assignment Template template< typename U, class = typename std::enable_if< std::is_assignable< T&, U >::value >::type > Array1S & From 90faf9d6b4904ebc5f51ffd54c00af4cee9e57b3 Mon Sep 17 00:00:00 2001 From: amirroth Date: Sat, 20 Jul 2024 15:52:57 -0400 Subject: [PATCH 110/115] More fixes and performance testing --- src/EnergyPlus/FluidProperties.cc | 186 ++++++++++++++++++------------ src/EnergyPlus/FluidProperties.hh | 22 ++++ 2 files changed, 132 insertions(+), 76 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 1d9880145a8..01b309eccc8 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -1118,11 +1118,15 @@ namespace FluidProperties { // be produced. // Propylene and ethylene are available by default - auto *waterRaw = new GlycolRawProps; - waterRaw->Name = "WATER"; - - df->glycolsRaw.push_back(waterRaw); - waterRaw->Num = df->glycolsRaw.isize(); + + auto *waterRaw = GetGlycolRaw(state, "WATER"); + if (waterRaw == nullptr) { + waterRaw = new GlycolRawProps; + waterRaw->Name = "WATER"; + + df->glycolsRaw.push_back(waterRaw); + waterRaw->Num = df->glycolsRaw.isize(); + } waterRaw->CpDataPresent = true; waterRaw->NumCpConcPoints = 1; @@ -1164,11 +1168,14 @@ namespace FluidProperties { waterRaw->ViscValues.allocate(waterRaw->NumViscConcPoints, waterRaw->NumViscTempPoints); waterRaw->ViscValues(1, {1, waterRaw->NumViscTempPoints}) = DefaultWaterViscData; - auto *ethylene = new GlycolRawProps; - ethylene->Name = "ETHYLENEGLYCOL"; - df->glycolsRaw.push_back(ethylene); - ethylene->Num = df->glycolsRaw.isize(); - + auto *ethylene = GetGlycolRaw(state, "ETHYLENEGLYCOL"); + if (ethylene == nullptr) { + ethylene = new GlycolRawProps; + ethylene->Name = "ETHYLENEGLYCOL"; + df->glycolsRaw.push_back(ethylene); + ethylene->Num = df->glycolsRaw.isize(); + } + // Specific Heat ethylene->CpDataPresent = true; // Flag set when specific heat data is available ethylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat @@ -1230,11 +1237,14 @@ namespace FluidProperties { ethylene->ViscValues(i, {1, ethylene->NumViscTempPoints}) = DefaultEthGlyViscData[i-1]; // Propylene - auto *propylene = new GlycolRawProps; - propylene->Name = "PROPYLENEGLYCOL"; - df->glycolsRaw.push_back(propylene); - propylene->Num = df->glycolsRaw.isize(); - + auto *propylene = GetGlycolRaw(state, "PROPYLENEGLYCOL"); + if (propylene == nullptr) { + propylene = new GlycolRawProps; + propylene->Name = "PROPYLENEGLYCOL"; + df->glycolsRaw.push_back(propylene); + propylene->Num = df->glycolsRaw.isize(); + } + // Specific Heat propylene->CpDataPresent = true; // Flag set when specific heat data is available propylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat @@ -1562,14 +1572,16 @@ namespace FluidProperties { CurrentModuleObject = "FluidProperties:GlycolConcentration"; NumOfOptionalInput = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject); - auto *water = new GlycolProps; - water->Name = "WATER"; - water->GlycolName = "WATER"; - water->used = true; // mark Water as always used - - df->glycols.push_back(water); - water->Num = df->glycols.isize(); - + auto *water = GetGlycol(state, "WATER"); + if (water == nullptr) { + water = new GlycolProps; + water->Name = "WATER"; + water->GlycolName = "WATER"; + water->used = true; // mark Water as always used + + df->glycols.push_back(water); + water->Num = df->glycols.isize(); + } water->Concentration = 1.0; water->CpDataPresent = true; water->NumCpTempPoints = DefaultNumGlyTemps; @@ -1596,6 +1608,7 @@ namespace FluidProperties { water->ViscTemps = DefaultGlycolTemps; water->ViscValues = DefaultWaterViscData; +#ifdef PERFORMANCE_OPT // This is a speed optimization. Maybe. water->CpTempRatios.allocate(water->NumCpTempPoints); for (int i = 1; i < water->NumCpTempPoints; ++i) @@ -1609,6 +1622,7 @@ namespace FluidProperties { water->ViscTempRatios.allocate(water->NumViscTempPoints); for (int i = 1; i < water->NumCondTempPoints; ++i) water->ViscTempRatios(i) = (water->ViscValues(i+1) - water->ViscValues(i)) / (water->ViscTemps(i+1) - water->ViscTemps(i)); +#endif // PERFORMANCE_OPT for (int Loop = 1; Loop <= NumOfOptionalInput; ++Loop) { state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1725,6 +1739,7 @@ namespace FluidProperties { InterpValuesForGlycolConc(state, glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints, glycolRaw->ViscConcs, glycolRaw->ViscValues, glycol->Concentration, glycol->ViscValues); +#ifdef PERFORMANCE_OPT // This is a speed optimization. Maybe. glycol->CpTempRatios.allocate(glycol->NumCpTempPoints); for (int i = 1; i < glycol->NumCpTempPoints; ++i) @@ -1738,6 +1753,7 @@ namespace FluidProperties { glycol->ViscTempRatios.allocate(glycol->NumViscTempPoints); for (int i = 1; i < glycol->NumCondTempPoints; ++i) glycol->ViscTempRatios(i) = (glycol->ViscValues(i+1) - glycol->ViscValues(i)) / (glycol->ViscTemps(i+1) - glycol->ViscTemps(i)); +#endif // PERFORMANCE_OPT } // for (Loop) if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols @@ -3948,12 +3964,12 @@ namespace FluidProperties { } Real64 GlycolProps::getSpecificHeat_raw(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input + Real64 const Temp, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) #else Real64 GlycolProps::getSpecificHeat(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input + Real64 const Temp, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) #endif @@ -3986,7 +4002,7 @@ namespace FluidProperties { assert(this->CpDataPresent); // Now determine the value of specific heat using interpolation - if (Temperature < this->CpLowTempValue) { // Temperature too low + if (Temp < this->CpLowTempValue) { // Temperature too low if (!state.dataGlobal->WarmupFlag) { df->glycolErrorLimits[(int)GlycolError::SpecHeatLow] = ++this->errors[(int)GlycolError::SpecHeatLow].count; @@ -3998,7 +4014,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->CpLowTempValue, this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4006,12 +4022,12 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), this->errors[(int)GlycolError::SpecHeatLow].index, - Temperature, + Temp, "{C}"); } return this->CpValues(this->CpLowTempIndex); - } else if (Temperature > this->CpHighTempValue) { // Temperature too high + } else if (Temp > this->CpHighTempValue) { // Temperature too high if (!state.dataGlobal->WarmupFlag) { df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] = ++this->errors[(int)GlycolError::SpecHeatHigh].count; if (df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] <= df->GlycolErrorLimitTest) { @@ -4020,7 +4036,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->CpLowTempValue, this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4028,30 +4044,27 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), this->errors[(int)GlycolError::SpecHeatHigh].index, - Temperature, + Temp, "{C}"); } return this->CpValues(this->CpHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - // bracket is temp > low, <= high (for interpolation - // for ( int Loop = glycol_data.CpLowTempIndex + 1; Loop <= glycol_data.CpHighTempIndex; ++Loop ) { //Tuned Replaced by binary search - // below if ( Temperature > glycol_data.CpTemps( Loop ) ) continue; return GetInterpValue( Temperature, glycol_CpTemps( Loop - 1 - //), glycol_CpTemps( Loop ), glycol_CpValues( Loop - 1 ), glycol_CpValues( Loop ) ); break; // DO loop - //} - // assert( std::is_sorted( glycol_CpTemps.begin(), glycol_CpTemps.end() ) ); // Sorted temperature array is assumed: Enable if/when arrays - // have begin()/end() - assert(this->CpTemps.size() <= - static_cast(std::numeric_limits::max())); // Array indexes are int now so this is future protection +#ifdef PERFORMANCE_OPT + if (Temp < this->CpTemps(this->LoCpTempIdxLast) || Temp > this->CpTemps(this->LoCpTempIdxLast+1)) { + this->LoCpTempIdxLast = FindArrayIndex(Temp, this->CpTemps, 1, this->NumCpTempPoints); + } + return this->CpValues(this->LoCpTempIdxLast) + (Temp - this->CpTemps(this->LoCpTempIdxLast)) * this->CpTempRatios(this->LoCpTempIdxLast); +#else // !PERFORMANCE_OPT + assert(this->CpTemps.size() <= static_cast(std::numeric_limits::max())); int beg(1), end(this->CpTemps.isize()); // 1-based indexing assert(end > 0); while (beg + 1 < end) { int mid = ((beg + end) >> 1); // bit shifting is faster than /2 (Temperature > this->CpTemps(mid) ? beg : end) = mid; } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] - - // Is this faster than Interp? return GetInterpValue(Temperature, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); +#endif // PERFORMANCE_OPT } } @@ -4079,7 +4092,7 @@ namespace FluidProperties { //***************************************************************************** Real64 GlycolProps::getDensity(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input + Real64 const Temp, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4103,7 +4116,7 @@ namespace FluidProperties { // all temperature lists are entered in ascending order. // Return value - Real64 ReturnValue; + Real64 Rho; // FUNCTION PARAMETERS: static constexpr std::string_view routineName = "GlycolProps::getDensity"; @@ -4117,16 +4130,23 @@ namespace FluidProperties { assert(this->RhoDataPresent); // Now determine the value of specific heat using interpolation - if (Temperature < this->RhoLowTempValue) { // Temperature too low + if (Temp < this->RhoLowTempValue) { // Temperature too low error = GlycolError::DensityLow; - ReturnValue = this->RhoValues(this->RhoLowTempIndex); - } else if (Temperature > this->RhoHighTempValue) { // Temperature too high + Rho = this->RhoValues(this->RhoLowTempIndex); + } else if (Temp > this->RhoHighTempValue) { // Temperature too high error = GlycolError::DensityHigh; - ReturnValue = this->RhoValues(this->RhoHighTempIndex); + Rho = this->RhoValues(this->RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value +#ifdef PERFORMANCE_OPT + if (Temp < this->RhoTemps(this->LoRhoTempIdxLast) || Temp > this->RhoTemps(this->LoRhoTempIdxLast+1)) { + this->LoRhoTempIdxLast = FindArrayIndex(Temp, this->RhoTemps, 1, this->NumRhoTempPoints); + } + Rho = this->RhoValues(this->LoRhoTempIdxLast) + (Temp - this->RhoTemps(this->LoRhoTempIdxLast)) * this->RhoTempRatios(this->LoRhoTempIdxLast); +#else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPoints); Real64 TempInterpRatio = (Temperature - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); ReturnValue = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); +#endif // PERFORMANCE_OPT } // Error handling @@ -4139,7 +4159,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->RhoLowTempValue, this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4148,7 +4168,7 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityLow].index, - Temperature, + Temp, "{C}"); } else { // error == GlycolError::DensityHigh @@ -4157,7 +4177,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->RhoLowTempValue, this->RhoHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4165,12 +4185,12 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] density **", routineName, this->Name), this->errors[(int)GlycolError::DensityHigh].index, - Temperature, + Temp, "{C}"); } } - return ReturnValue; + return Rho; } Real64 GetDensityGlycol(EnergyPlusData &state, @@ -4197,7 +4217,7 @@ namespace FluidProperties { //***************************************************************************** Real64 GlycolProps::getConductivity(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input + Real64 const Temp, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4221,7 +4241,7 @@ namespace FluidProperties { // all temperature lists are entered in ascending order. // Return value - Real64 ReturnValue; + Real64 Cond; // FUNCTION PARAMETERS: static constexpr std::string_view routineName = "GlycolProps::getConductivity"; @@ -4239,16 +4259,23 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - if (Temperature < this->CondLowTempValue) { // Temperature too low + if (Temp < this->CondLowTempValue) { // Temperature too low error = GlycolError::ConductivityLow; - ReturnValue = this->CondValues(this->CondLowTempIndex); - } else if (Temperature > this->CondHighTempValue) { // Temperature too high + Cond = this->CondValues(this->CondLowTempIndex); + } else if (Temp > this->CondHighTempValue) { // Temperature too high error = GlycolError::ConductivityHigh; - ReturnValue = this->CondValues(this->CondHighTempIndex); + Cond = this->CondValues(this->CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value +#ifdef PERFORMANCE_OPT + if (Temp < this->CondTemps(this->LoCondTempIdxLast) || Temp > this->CondTemps(this->LoCondTempIdxLast+1)) { + this->LoCondTempIdxLast = FindArrayIndex(Temp, this->CondTemps, 1, this->NumCondTempPoints); + } + Cond = this->CondValues(this->LoCondTempIdxLast) + (Temp - this->CondTemps(this->LoCondTempIdxLast)) * this->CondTempRatios(this->LoCondTempIdxLast); +#else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPoints); Real64 TempInterpRatio = (Temperature - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); ReturnValue = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); +#endif // PERFORMANCE_OPT } // Error handling @@ -4261,7 +4288,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->CondLowTempValue, this->CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4270,7 +4297,7 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), this->errors[(int)error].index, - Temperature, + Temp, "{C}"); } @@ -4280,7 +4307,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->CondLowTempValue, this->CondHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4289,12 +4316,12 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), this->errors[(int)error].index, - Temperature, + Temp, "{C}"); } } - return ReturnValue; + return Cond; } // GlycolProps::getConductivity() Real64 GetConductivityGlycol(EnergyPlusData &state, @@ -4322,7 +4349,7 @@ namespace FluidProperties { //***************************************************************************** Real64 GlycolProps::getViscosity(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input + Real64 const Temp, // actual temperature given as input std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4346,7 +4373,7 @@ namespace FluidProperties { // all temperature lists are entered in ascending order. // Return value - Real64 ReturnValue; // Value for function + Real64 Visc; // Value for function // FUNCTION PARAMETERS: static constexpr std::string_view routineName = "GlycolProps::getViscosity"; @@ -4364,16 +4391,23 @@ namespace FluidProperties { } // Now determine the value of specific heat using interpolation - if (Temperature < this->ViscLowTempValue) { // Temperature too low + if (Temp < this->ViscLowTempValue) { // Temperature too low error = GlycolError::ViscosityLow; - ReturnValue = this->ViscValues(this->ViscLowTempIndex); - } else if (Temperature > this->ViscHighTempValue) { // Temperature too high + Visc = this->ViscValues(this->ViscLowTempIndex); + } else if (Temp > this->ViscHighTempValue) { // Temperature too high error = GlycolError::ViscosityHigh; - ReturnValue = this->ViscValues(this->ViscHighTempIndex); + Visc = this->ViscValues(this->ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value - int LoTempIndex = FindArrayIndex(Temperature, this->ViscTemps, 1, this->NumViscTempPoints); +#ifdef PERFORMANCE_OPT + if (Temp < this->ViscTemps(this->LoViscTempIdxLast) || Temp > this->ViscTemps(this->LoViscTempIdxLast+1)) { + this->LoViscTempIdxLast = FindArrayIndex(Temp, this->ViscTemps, 1, this->NumViscTempPoints); + } + Visc = this->ViscValues(this->LoViscTempIdxLast) + (Temp - this->ViscTemps(this->LoViscTempIdxLast)) * this->ViscTempRatios(this->LoViscTempIdxLast); +#else // !PERFORMANCE_OPT + int LoTempIndex = FindArrayIndex(Temp, this->ViscTemps, 1, this->NumViscTempPoints); Real64 TempInterpRatio = (Temperature - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); ReturnValue = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); +#endif // PERFORMANCE_OPT } // Error handling @@ -4386,7 +4420,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->ViscLowTempValue, this->ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4395,7 +4429,7 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too low) for fluid [{}] viscosity **", routineName, this->Name), this->errors[(int)GlycolError::ViscosityLow].index, - Temperature, + Temp, "{C}"); } @@ -4405,7 +4439,7 @@ namespace FluidProperties { ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, - Temperature, + Temp, this->ViscLowTempValue, this->ViscHighTempValue)); ShowContinueErrorTimeStamp(state, ""); @@ -4414,12 +4448,12 @@ namespace FluidProperties { ShowRecurringWarningErrorAtEnd(state, format("{}: Temperature out of range (too high) for fluid [{}] viscosity **", routineName, this->Name), this->errors[(int)GlycolError::ViscosityHigh].index, - Temperature, + Temp, "{C}"); } } - return ReturnValue; + return Visc; } // GlycolProps::getViscosity() Real64 GetViscosityGlycol(EnergyPlusData &state, diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index 37f765807da..a20c1254264 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -69,6 +69,8 @@ struct EnergyPlusData; namespace FluidProperties { +#define PERFORMANCE_OPT + #ifdef EP_cache_GlycolSpecificHeat int constexpr t_sh_cache_size = 1024 * 1024; int constexpr t_sh_precision_bits = 24; @@ -114,7 +116,9 @@ namespace FluidProperties { int PsHighPresIndex = 0; // High Pressure Max Index for Ps (>0.0) Array1D PsTemps; // Temperatures for saturation pressures Array1D PsValues; // Saturation pressures at PsTemps +#ifdef PERFORMANCE_OPT Array1D PsTempRatios; // PsTempRatios(i) = (PsValues(i+1) - PsValues(i)) / (PsTemps(i+1) - PsTemps(i)). Speed optimization. +#endif // PERFORMANCE_OPT int NumHPoints = 0; // Number of enthalpy points Real64 HfLowTempValue = 0.0; // Low Temperature Value for Hf (>0.0) @@ -128,8 +132,10 @@ namespace FluidProperties { Array1D HTemps; // Temperatures for enthalpy points Array1D HfValues; // Enthalpy of saturated fluid at HTemps Array1D HfgValues; // Enthalpy of saturated fluid/gas at HTemps +#ifdef PERFORMANCE_OPT Array1D HfTempRatios; Array1D HfgTempRatios; +#endif // PERFORMANCE_OPT int NumCpPoints = 0; // Number of specific heat of fluid points Real64 CpfLowTempValue = 0.0; // Low Temperature Value for Cpf (>0.0) @@ -143,8 +149,10 @@ namespace FluidProperties { Array1D CpTemps; // Temperatures for specific heat points Array1D CpfValues; // Specific heat of saturated fluid at CpTemps Array1D CpfgValues; // Specific heat of saturated fluid/gas at CpTemps +#ifdef PERFORMANCE_OPT Array1D CpfTempRatios; Array1D CpfgTempRatios; +#endif // PERFORMANCE_OPT int NumRhoPoints = 0; // Number of density of fluid points Real64 RhofLowTempValue = 0.0; // Low Temperature Value for Rhof (>0.0) @@ -158,8 +166,10 @@ namespace FluidProperties { Array1D RhoTemps; // Temperatures for density of fluid points Array1D RhofValues; // Density of saturated fluid at RhoTemps Array1D RhofgValues; // Density of saturated fluid/gas at RhoTemps +#ifdef PERFORMANCE_OPT Array1D RhofTempRatios; Array1D RhofgTempRatios; +#endif // PERFORMANCE_OPT int NumSupTempPoints = 0; // Number of temperature points for superheated enthalpy int NumSupPressPoints = 0; // Number of pressure points for superheated enthalpy @@ -295,7 +305,10 @@ namespace FluidProperties { int NumCpTempPoints = 0; // Number of temperature points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpValues; // Specific heat data values (J/kg-K) +#ifdef PERFORMANCE_OPT + int LoCpTempIdxLast = 1; Array1D CpTempRatios; // Speed optimization +#endif // PERFORMANCE_OPT bool RhoDataPresent = false; // Flag set when density data is available int NumRhoTempPoints = 0.0; // Number of temperature points for density @@ -305,7 +318,10 @@ namespace FluidProperties { int RhoHighTempIndex = 0; // High Temperature Max Index for Rho (>0.0) Array1D RhoTemps; // Temperatures for density of glycol Array1D RhoValues; // Density data values (kg/m3) +#ifdef PERFORMANCE_OPT + int LoRhoTempIdxLast = 1; Array1D RhoTempRatios; // Speed optimization +#endif // PERFORMANCE_OPT bool CondDataPresent = false; // Flag set when conductivity data is available int NumCondTempPoints = 0; // Number of temperature points for conductivity @@ -315,7 +331,10 @@ namespace FluidProperties { int CondHighTempIndex = 0; // High Temperature Max Index for Cond (>0.0) Array1D CondTemps; // Temperatures for conductivity of glycol Array1D CondValues; // conductivity values (W/m-K) +#ifdef PERFORMANCE_OPT + int LoCondTempIdxLast = 1; Array1D CondTempRatios; // Speed optimization +#endif // PERFORMANCE_OPT bool ViscDataPresent = false; // Flag set when viscosity data is available int NumViscTempPoints = 0; // Number of temperature points for viscosity @@ -325,7 +344,10 @@ namespace FluidProperties { int ViscHighTempIndex = 0; // High Temperature Max Index for Visc (>0.0) Array1D ViscTemps; // Temperatures for viscosity of glycol Array1D ViscValues; // viscosity values (mPa-s) +#ifdef PERFORMANCE_OPT + int LoViscTempIdxLast = 1; Array1D ViscTempRatios; +#endif // PERFORMANCE_OPT std::array errors; From 08e24a17bdf284b0bbad543c76d7e2bea332d7c4 Mon Sep 17 00:00:00 2001 From: amirroth Date: Sat, 20 Jul 2024 17:34:01 -0400 Subject: [PATCH 111/115] Disable performance optimizations --- src/EnergyPlus/FluidProperties.cc | 20 ++++++++++---------- src/EnergyPlus/FluidProperties.hh | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 01b309eccc8..a017ed81bac 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -4061,9 +4061,9 @@ namespace FluidProperties { assert(end > 0); while (beg + 1 < end) { int mid = ((beg + end) >> 1); // bit shifting is faster than /2 - (Temperature > this->CpTemps(mid) ? beg : end) = mid; + (Temp > this->CpTemps(mid) ? beg : end) = mid; } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] - return GetInterpValue(Temperature, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); + return GetInterpValue(Temp, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); #endif // PERFORMANCE_OPT } } @@ -4143,9 +4143,9 @@ namespace FluidProperties { } Rho = this->RhoValues(this->LoRhoTempIdxLast) + (Temp - this->RhoTemps(this->LoRhoTempIdxLast)) * this->RhoTempRatios(this->LoRhoTempIdxLast); #else // !PERFORMANCE_OPT - int LoTempIndex = FindArrayIndex(Temperature, this->RhoTemps, 1, this->NumRhoTempPoints); - Real64 TempInterpRatio = (Temperature - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); - ReturnValue = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); + int LoTempIndex = FindArrayIndex(Temp, this->RhoTemps, 1, this->NumRhoTempPoints); + Real64 TempInterpRatio = (Temp - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); + Rho = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); #endif // PERFORMANCE_OPT } @@ -4272,9 +4272,9 @@ namespace FluidProperties { } Cond = this->CondValues(this->LoCondTempIdxLast) + (Temp - this->CondTemps(this->LoCondTempIdxLast)) * this->CondTempRatios(this->LoCondTempIdxLast); #else // !PERFORMANCE_OPT - int LoTempIndex = FindArrayIndex(Temperature, this->CondTemps, 1, this->NumCondTempPoints); - Real64 TempInterpRatio = (Temperature - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); - ReturnValue = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); + int LoTempIndex = FindArrayIndex(Temp, this->CondTemps, 1, this->NumCondTempPoints); + Real64 TempInterpRatio = (Temp - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); + Cond = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); #endif // PERFORMANCE_OPT } @@ -4405,8 +4405,8 @@ namespace FluidProperties { Visc = this->ViscValues(this->LoViscTempIdxLast) + (Temp - this->ViscTemps(this->LoViscTempIdxLast)) * this->ViscTempRatios(this->LoViscTempIdxLast); #else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temp, this->ViscTemps, 1, this->NumViscTempPoints); - Real64 TempInterpRatio = (Temperature - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); - ReturnValue = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); + Real64 TempInterpRatio = (Temp - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); + Visc = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); #endif // PERFORMANCE_OPT } diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index a20c1254264..c3a42ac9e40 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -69,7 +69,7 @@ struct EnergyPlusData; namespace FluidProperties { -#define PERFORMANCE_OPT +#undef PERFORMANCE_OPT #ifdef EP_cache_GlycolSpecificHeat int constexpr t_sh_cache_size = 1024 * 1024; From dbdea7b80033ea460853cb38824dd8eee7e26122 Mon Sep 17 00:00:00 2001 From: Jason Glazer Date: Tue, 23 Jul 2024 08:18:46 -0500 Subject: [PATCH 112/115] Removed lines causing latex error and clean up --- .../src/output-files/eplustbl-lt-ext-gt.tex | 62 ------------------- 1 file changed, 62 deletions(-) diff --git a/doc/output-details-and-examples/src/output-files/eplustbl-lt-ext-gt.tex b/doc/output-details-and-examples/src/output-files/eplustbl-lt-ext-gt.tex index 2d061ec9a36..fed96eb1b70 100644 --- a/doc/output-details-and-examples/src/output-files/eplustbl-lt-ext-gt.tex +++ b/doc/output-details-and-examples/src/output-files/eplustbl-lt-ext-gt.tex @@ -1018,8 +1018,6 @@ \subsection{Equipment Summary}\label{equipment-summary} Plantloop Branch Name \end{itemize} -An example of the report is shown here - \begin{figure}[h!] \centering \includegraphics{media/boiler-table-example.PNG} @@ -1053,8 +1051,6 @@ \subsection{Equipment Summary}\label{equipment-summary} Condenser Loop Branch Name \end{itemize} -An example of the report is shown here - \begin{figure}[h!] \centering \includegraphics{media/cooling-tower-table-example.PNG} @@ -1078,8 +1074,6 @@ \subsection{Equipment Summary}\label{equipment-summary} Minimum Loop Flow Rate [m3/s] \end{itemize} -An example of the report is shown here - \begin{figure}[h!] \centering \includegraphics{media/plantloop-table-example.PNG} @@ -1127,8 +1121,6 @@ \subsection{Equipment Summary}\label{equipment-summary} Minimum Outdoor Flow Schedule Name \end{itemize} -An example of the report is shown here - \begin{figure}[h!] \centering \includegraphics{media/air-terminal-table-example.PNG} @@ -1160,7 +1152,6 @@ \subsection{Equipment Summary}\label{equipment-summary} Outdoor Airflow [kg/s] \end{itemize} -An example of the report is shown here \begin{figure}[h!] \centering @@ -1168,59 +1159,6 @@ \subsection{Equipment Summary}\label{equipment-summary} \caption{} \end{figure} -{\scriptsize -\begin{longtable}[c]{>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}} -\toprule -~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline -~ & Type & Reference Capacity[W] & Type Reference Efficiency [W/W] & Rated Capacity [W] & Rated Efficiency [W/W] & IPLV in SI Units [W/W] & IPLV in IP Units [Btu/W-h] & Minimum Part Load Ratio & Fuel Type & Rated Entering Condenser Temperature [C] & Rated Leaving Evaporator Temperature [C] Reference Entering Condenser Temperature [C] Reference Leaving Evaporator Temperature [C] Design Size Reference Chilled Water Flow Rate [kg/s] Design Size Reference Condenser Fluid Flow Rate [kg/s] Plantloop Name Plantloop Branch Name Condenser Loop Name Condenser Loop Branch Name Heat Recovery Plantloop Name Heat Recovery Plantloop Branch Name Recovery Relative Capacity Fraction - -\midrule -\endfirsthead - -\toprule -~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline -\midrule -\endhead - -Type Reference Capacity[W] TypeReference Efficiency [W/W] Rated Capacity [W] Rated Efficiency [W/W] IPLV in SI Units [W/W] IPLV in IP Units [Btu/W-h] Minimum Part Load Ratio Fuel Type Rated Entering Condenser Temperature [C] Rated Leaving Evaporator Temperature [C] Reference Entering Condenser Temperature [C] Reference Leaving Evaporator Temperature [C] Design Size Reference Chilled Water Flow Rate [kg/s] Design Size Reference Condenser Fluid Flow Rate [kg/s] Plantloop Name Plantloop Branch Name Condenser Loop Name Condenser Loop Branch Name Heat Recovery Plantloop Name Heat Recovery Plantloop Branch Name Recovery Relative Capacity Fraction -90.1-2004 WATERCOOLED CENTRIFUGAL CHILLER 0 416TONS 0.6KW/TON Chiller:Electric:EIR 1932343.27 6.10 1932343.27 6.10 6.88 6.92 0.00 Electricity 35.00 6.67 35.00 6.67 82.04 96.29 CHILLED WATER LOOP CHILLED WATER LOOP SUPPLY BRANCH 1 CONDENSER WATER LOOP CONDENSER WATER LOOP DEMAND BRANCH 2 N/A N/A 0.00 -90.1-2004 WATERCOOLED CENTRIFUGAL CHILLER 1 416TONS 0.6KW/TON Chiller:Electric:EIR 1932343.27 6.10 1932343.27 6.10 6.88 6.92 0.00 Electricity 35.00 6.67 35.00 6.67 82.04 96.29 CHILLED WATER LOOP CHILLED WATER LOOP SUPPLY BRANCH 2 CONDENSER WATER LOOP CONDENSER WATER LOOP DEMAND BRANCH 3 N/A N/A 0.00 - - - - - - -SPACE1-1 ZONE COIL & Coil:Heating:Fuel & 17614.83 & 0.80 \tabularnewline -SPACE2-1 ZONE COIL & Coil:Heating:Fuel & 14619.82 & 0.80 \tabularnewline -SPACE3-1 ZONE COIL & Coil:Heating:Fuel & 16093.74 & 0.80 \tabularnewline -SPACE4-1 ZONE COIL & Coil:Heating:Fuel & 18942.35 & 0.80 \tabularnewline -SPACE5-1 ZONE COIL & Coil:Heating:Fuel & 19146.73 & 0.80 \tabularnewline -MAIN HEATING COIL 1 & Coil:Heating:Fuel & 19754.61 & 0.80 \tabularnewline -\bottomrule -\end{longtable}} - -{\scriptsize -\begin{longtable}[c]{>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}>{\raggedright}p{1.5in}} -\toprule -~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline -\midrule -\endfirsthead - -\toprule -~ & Type & Nominal Total Capacity (W) & Nominal Efficiency (W/W) \tabularnewline -\midrule -\endhead - -SPACE1-1 ZONE COIL & Coil:Heating:Fuel & 17614.83 & 0.80 \tabularnewline -SPACE2-1 ZONE COIL & Coil:Heating:Fuel & 14619.82 & 0.80 \tabularnewline -SPACE3-1 ZONE COIL & Coil:Heating:Fuel & 16093.74 & 0.80 \tabularnewline -SPACE4-1 ZONE COIL & Coil:Heating:Fuel & 18942.35 & 0.80 \tabularnewline -SPACE5-1 ZONE COIL & Coil:Heating:Fuel & 19146.73 & 0.80 \tabularnewline -MAIN HEATING COIL 1 & Coil:Heating:Fuel & 19754.61 & 0.80 \tabularnewline -\bottomrule -\end{longtable}} - \subsection{Envelope Summary}\label{envelope-summary} From c842eecd8d83750518cc5b575761bea46d8cb0f2 Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Wed, 24 Jul 2024 10:33:30 -0500 Subject: [PATCH 113/115] Apply clang format --- src/EnergyPlus/BoilerSteam.cc | 4 +- src/EnergyPlus/FluidProperties.cc | 5293 +++++++++-------- src/EnergyPlus/FluidProperties.hh | 331 +- src/EnergyPlus/HVACVariableRefrigerantFlow.cc | 275 +- src/EnergyPlus/HVACVariableRefrigerantFlow.hh | 82 +- src/EnergyPlus/OutdoorAirUnit.cc | 14 +- src/EnergyPlus/Plant/Loop.cc | 8 +- src/EnergyPlus/Plant/LoopSide.cc | 8 +- src/EnergyPlus/Plant/PlantManager.cc | 36 +- src/EnergyPlus/PoweredInductionUnits.cc | 14 +- src/EnergyPlus/SingleDuct.cc | 17 +- src/EnergyPlus/SteamCoils.cc | 22 +- src/EnergyPlus/UnitHeater.cc | 12 +- src/EnergyPlus/UtilityRoutines.cc | 10 +- src/EnergyPlus/UtilityRoutines.hh | 25 +- src/EnergyPlus/VentilatedSlab.cc | 15 +- src/EnergyPlus/WaterToAirHeatPump.cc | 68 +- tst/EnergyPlus/unit/FluidProperties.unit.cc | 12 +- .../unit/HVACVariableRefrigerantFlow.unit.cc | 24 +- .../unit/LowTempRadiantSystem.unit.cc | 88 +- tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc | 17 +- tst/EnergyPlus/unit/UnitHeater.unit.cc | 33 +- tst/EnergyPlus/unit/WaterCoils.unit.cc | 6 +- .../unit/WaterToAirHeatPump.unit.cc | 2 +- 24 files changed, 3230 insertions(+), 3186 deletions(-) diff --git a/src/EnergyPlus/BoilerSteam.cc b/src/EnergyPlus/BoilerSteam.cc index 2d6b3a82184..8cb9a6534dd 100644 --- a/src/EnergyPlus/BoilerSteam.cc +++ b/src/EnergyPlus/BoilerSteam.cc @@ -269,8 +269,8 @@ namespace BoilerSteam { if (SteamFluidIndex == 0 && BoilerNum == 1) { SteamFluidIndex = FluidProperties::GetRefrigNum(state, fluidNameSteam); // Steam is a refrigerant? if (SteamFluidIndex == 0) { - ShowSevereError( - state, format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); + ShowSevereError( + state, format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError(state, "Steam Properties not found; Steam Fluid Properties must be included in the input file."); ErrorsFound = true; } diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index a017ed81bac..963be054cfa 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -107,72 +107,72 @@ namespace FluidProperties { constexpr int DefaultNumSteamTemps(111); // Temperature dimension of default steam data. constexpr int DefaultNumSteamSuperheatedTemps(114); // Temperature dimension of default steam data. constexpr int DefaultNumSteamSuperheatedPressure(114); // Temperature dimension of default steam data. - + static constexpr std::array DefaultGlycolTemps = { -35.0, -30.0, -25.0, -20.0, -15.0, -10.0, -5.0, 0.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 75.0, 80.0, 85.0, 90.0, 95.0, 100.0, 105.0, 110.0, 115.0, 120.0, 125.0}; // 33 total temperature // points - inline int GlycolTempToTempIndex(Real64 Temp) { - return (int)(Temp / 5.0) + ((Temp < 0.0) ? 6 : 7); + inline int GlycolTempToTempIndex(Real64 Temp) + { + return (int)(Temp / 5.0) + ((Temp < 0.0) ? 6 : 7); } - + static constexpr std::array DefaultGlycolConcs = { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; // 10 total concentration points static constexpr std::array DefaultWaterCpData = { - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 4217.0, 4198.0, 4191.0, 4185.0, 4181.0, 4179.0, 4180.0, - 4180.0, 4180.0, 4180.0, 4181.0, 4183.0, 4185.0, 4188.0, - 4192.0, 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, - 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}; // in J/kg-K + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, + 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}; // in J/kg-K static constexpr std::array DefaultWaterViscData = { 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3, 1.7912e-3, 1.5183e-3, 1.306e-3, 1.1376e-3, 1.0016e-3, 0.8901e-3, 0.7974e-3, 0.7193e-3, 0.653e-3, 0.5961e-3, 0.5468e-3, 0.504e-3, 0.4664e-3, 0.4332e-3, 0.4039e-3, 0.3777e-3, 0.3543e-3, 0.3333e-3, 0.3144e-3, 0.2973e-3, 0.2817e-3, 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3, 0.0e-3}; // in Pa-s - + static constexpr std::array DefaultWaterRhoData = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 999.8, 999.9, 999.7, 999.1, 998.2, 997.0, 995.6, 994.0, 992.2, 990.2, 988.0, 985.7, 983.2, 980.5, 977.7, 974.8, 971.8, 968.6, 965.3, 961.9, 958.3, 0.0, 0.0, 0.0, 0.0, 0.0}; // in kg/m3 - + static constexpr std::array DefaultWaterCondData = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.5705, 0.58, 0.5893, 0.5984, 0.6072, 0.6155, 0.6233, 0.6306, 0.6373, 0.6436, 0.6492, 0.6543, 0.659, 0.6631, 0.6668, 0.67, 0.6728, 0.6753, 0.6773, 0.6791, 0.0, 0.0, 0.0, 0.0, 0.0}; // in W/mK - + // Ethylene Glycol Data: Specific Heat in J/(kg-k) - static constexpr std::array, DefaultNumGlyConcs> DefaultEthGlyCpData = { - {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, - 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, - 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3937.0, 3946.0, 3954.0, 3963.0, - 3972.0, 3981.0, 3989.0, 3998.0, 4007.0, 4015.0, 4024.0, 4033.0, 4042.0, 4050.0, 4059.0, - 4068.0, 4077.0, 4085.0, 4094.0, 4103.0, 4112.0, 4120.0, 4129.0, 4138.0, 4147.0, 4155.0}, // Conc=0.1 - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3757.0, 3769.0, 3780.0, 3792.0, 3803.0, - 3815.0, 3826.0, 3838.0, 3849.0, 3861.0, 3872.0, 3884.0, 3895.0, 3907.0, 3918.0, 3930.0, - 3941.0, 3953.0, 3964.0, 3976.0, 3987.0, 3999.0, 4010.0, 4022.0, 4033.0, 4045.0, 4056.0}, // Conc=0.2 - {0.0, 0.0, 0.0, 0.0, 0.0, 3560.0, 3574.0, 3589.0, 3603.0, 3617.0, 3631.0, - 3645.0, 3660.0, 3674.0, 3688.0, 3702.0, 3716.0, 3730.0, 3745.0, 3759.0, 3773.0, 3787.0, - 3801.0, 3816.0, 3830.0, 3844.0, 3858.0, 3872.0, 3886.0, 3901.0, 3915.0, 3929.0, 3943.0}, // Conc=0.3 - {0.0, 0.0, 0.0, 3334.0, 3351.0, 3367.0, 3384.0, 3401.0, 3418.0, 3435.0, 3451.0, - 3468.0, 3485.0, 3502.0, 3518.0, 3535.0, 3552.0, 3569.0, 3585.0, 3602.0, 3619.0, 3636.0, - 3653.0, 3669.0, 3686.0, 3703.0, 3720.0, 3736.0, 3753.0, 3770.0, 3787.0, 3804.0, 3820.0}, // Conc=0.4 - {3068.0, 3088.0, 3107.0, 3126.0, 3145.0, 3165.0, 3184.0, 3203.0, 3223.0, 3242.0, 3261.0, - 3281.0, 3300.0, 3319.0, 3339.0, 3358.0, 3377.0, 3396.0, 3416.0, 3435.0, 3454.0, 3474.0, - 3493.0, 3512.0, 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, 3647.0, 3667.0, 3686.0}, // Conc=0.5 - {2844.0, 2866.0, 2888.0, 2909.0, 2931.0, 2953.0, 2975.0, 2997.0, 3018.0, 3040.0, 3062.0, - 3084.0, 3106.0, 3127.0, 3149.0, 3171.0, 3193.0, 3215.0, 3236.0, 3258.0, 3280.0, 3302.0, - 3324.0, 3345.0, 3367.0, 3389.0, 3411.0, 3433.0, 3454.0, 3476.0, 3498.0, 3520.0, 3542.0}, // Conc=0.6 - {2612.0, 2636.0, 2660.0, 2685.0, 2709.0, 2733.0, 2757.0, 2782.0, 2806.0, 2830.0, 2854.0, - 2878.0, 2903.0, 2927.0, 2951.0, 2975.0, 3000.0, 3024.0, 3048.0, 3072.0, 3097.0, 3121.0, - 3145.0, 3169.0, 3193.0, 3218.0, 3242.0, 3266.0, 3290.0, 3315.0, 3339.0, 3363.0, 3387.0}, // Conc=0.7 - {2370.0, 2397.0, 2423.0, 2450.0, 2477.0, 2503.0, 2530.0, 2556.0, 2583.0, 2610.0, 2636.0, - 2663.0, 2690.0, 2716.0, 2743.0, 2770.0, 2796.0, 2823.0, 2850.0, 2876.0, 2903.0, 2929.0, - 2956.0, 2983.0, 3009.0, 3036.0, 3063.0, 3089.0, 3116.0, 3143.0, 3169.0, 3196.0, 3223.0}, // Conc=0.8 - {0.0, 0.0, 2177.0, 2206.0, 2235.0, 2264.0, 2293.0, 2322.0, 2351.0, 2380.0, 2409.0, - 2438.0, 2467.0, 2496.0, 2525.0, 2554.0, 2583.0, 2612.0, 2641.0, 2670.0, 2699.0, 2728.0, - 2757.0, 2786.0, 2815.0, 2844.0, 2873.0, 2902.0, 2931.0, 2960.0, 2989.0, 3018.0, 3047.0}} // Conc=0.9 + static constexpr std::array, DefaultNumGlyConcs> + DefaultEthGlyCpData = + { + {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, + 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, + 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3937.0, 3946.0, 3954.0, 3963.0, + 3972.0, 3981.0, 3989.0, 3998.0, 4007.0, 4015.0, 4024.0, 4033.0, 4042.0, 4050.0, 4059.0, + 4068.0, 4077.0, 4085.0, 4094.0, 4103.0, 4112.0, 4120.0, 4129.0, 4138.0, 4147.0, 4155.0}, // Conc=0.1 + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3757.0, 3769.0, 3780.0, 3792.0, 3803.0, + 3815.0, 3826.0, 3838.0, 3849.0, 3861.0, 3872.0, 3884.0, 3895.0, 3907.0, 3918.0, 3930.0, + 3941.0, 3953.0, 3964.0, 3976.0, 3987.0, 3999.0, 4010.0, 4022.0, 4033.0, 4045.0, 4056.0}, // Conc=0.2 + {0.0, 0.0, 0.0, 0.0, 0.0, 3560.0, 3574.0, 3589.0, 3603.0, 3617.0, 3631.0, + 3645.0, 3660.0, 3674.0, 3688.0, 3702.0, 3716.0, 3730.0, 3745.0, 3759.0, 3773.0, 3787.0, + 3801.0, 3816.0, 3830.0, 3844.0, 3858.0, 3872.0, 3886.0, 3901.0, 3915.0, 3929.0, 3943.0}, // Conc=0.3 + {0.0, 0.0, 0.0, 3334.0, 3351.0, 3367.0, 3384.0, 3401.0, 3418.0, 3435.0, 3451.0, + 3468.0, 3485.0, 3502.0, 3518.0, 3535.0, 3552.0, 3569.0, 3585.0, 3602.0, 3619.0, 3636.0, + 3653.0, 3669.0, 3686.0, 3703.0, 3720.0, 3736.0, 3753.0, 3770.0, 3787.0, 3804.0, 3820.0}, // Conc=0.4 + {3068.0, 3088.0, 3107.0, 3126.0, 3145.0, 3165.0, 3184.0, 3203.0, 3223.0, 3242.0, 3261.0, + 3281.0, 3300.0, 3319.0, 3339.0, 3358.0, 3377.0, 3396.0, 3416.0, 3435.0, 3454.0, 3474.0, + 3493.0, 3512.0, 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, 3647.0, 3667.0, 3686.0}, // Conc=0.5 + {2844.0, 2866.0, 2888.0, 2909.0, 2931.0, 2953.0, 2975.0, 2997.0, 3018.0, 3040.0, 3062.0, + 3084.0, 3106.0, 3127.0, 3149.0, 3171.0, 3193.0, 3215.0, 3236.0, 3258.0, 3280.0, 3302.0, + 3324.0, 3345.0, 3367.0, 3389.0, 3411.0, 3433.0, 3454.0, 3476.0, 3498.0, 3520.0, 3542.0}, // Conc=0.6 + {2612.0, 2636.0, 2660.0, 2685.0, 2709.0, 2733.0, 2757.0, 2782.0, 2806.0, 2830.0, 2854.0, + 2878.0, 2903.0, 2927.0, 2951.0, 2975.0, 3000.0, 3024.0, 3048.0, 3072.0, 3097.0, 3121.0, + 3145.0, 3169.0, 3193.0, 3218.0, 3242.0, 3266.0, 3290.0, 3315.0, 3339.0, 3363.0, 3387.0}, // Conc=0.7 + {2370.0, 2397.0, 2423.0, 2450.0, 2477.0, 2503.0, 2530.0, 2556.0, 2583.0, 2610.0, 2636.0, + 2663.0, 2690.0, 2716.0, 2743.0, 2770.0, 2796.0, 2823.0, 2850.0, 2876.0, 2903.0, 2929.0, + 2956.0, 2983.0, 3009.0, 3036.0, 3063.0, 3089.0, 3116.0, 3143.0, 3169.0, 3196.0, 3223.0}, // Conc=0.8 + {0.0, 0.0, 2177.0, 2206.0, 2235.0, 2264.0, 2293.0, 2322.0, 2351.0, 2380.0, 2409.0, + 2438.0, 2467.0, 2496.0, 2525.0, 2554.0, 2583.0, 2612.0, 2641.0, 2670.0, 2699.0, 2728.0, + 2757.0, 2786.0, 2815.0, 2844.0, 2873.0, 2902.0, 2931.0, 2960.0, 2989.0, 3018.0, 3047.0}} // Conc=0.9 }; // Ethylene Glycol Data: Viscosity in mPa-s @@ -208,7 +208,7 @@ namespace FluidProperties { 1.295e-02, 1.059e-02, 8.77e-03, 7.34e-03, 6.21e-03, 5.30e-03, 4.56e-03, 3.95e-03, 3.45e-03, 3.03e-03, 2.67e-03, 2.37e-03, 2.12e-03, 1.90e-03, 1.71e-03, 1.54e-03, 1.40e-03, 1.27e-03, 1.16e-03, 1.07e-03, 9.8e-04, 9.0e-04}} // Conc = 0.9 }; - + // Ethylene Glycol Data: Density in kg/m3 static constexpr std::array, DefaultNumGlyConcs> DefaultEthGlyRhoData = { {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 999.8, 999.9, 999.7, 999.1, 998.2, 997.0, 995.6, 994.0, 992.2, 990.2, @@ -243,62 +243,57 @@ namespace FluidProperties { }; // Ethylene Glycol Data: Conductivity in W/(m-K) - static constexpr std::array, DefaultNumGlyConcs> DefaultEthGlyCondData = { - {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.5705, 0.58, 0.5893, - 0.5984, 0.6072, 0.6155, 0.6233, 0.6306, 0.6373, 0.6436, 0.6492, 0.6543, 0.659, 0.6631, - 0.6668, 0.67, 0.6728, 0.6753, 0.6773, 0.6791, 0.0, 0.0, 0.0, 0.0, 0.0}, // DefaultWaterCondData - {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.511, 0.520, 0.528, 0.537, 0.545, 0.552, 0.559, 0.566, 0.572, 0.577, - 0.583, 0.588, 0.592, 0.596, 0.600, 0.603, 0.606, 0.608, 0.610, 0.612, 0.613, 0.614, 0.614, 0.614, 0.613, 0.612}, // Conc=0.1 - {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.460, 0.468, 0.476, 0.483, 0.490, 0.497, 0.503, 0.509, 0.515, 0.520, 0.525, - 0.529, 0.534, 0.538, 0.541, 0.544, 0.547, 0.549, 0.551, 0.553, 0.555, 0.556, 0.556, 0.557, 0.557, 0.556, 0.555}, // Conc=0.2 - {0.000, 0.000, 0.000, 0.000, 0.000, 0.415, 0.422, 0.429, 0.436, 0.442, 0.448, 0.453, 0.459, 0.464, 0.469, 0.473, 0.477, - 0.481, 0.485, 0.488, 0.491, 0.494, 0.496, 0.498, 0.500, 0.501, 0.503, 0.504, 0.504, 0.505, 0.505, 0.504, 0.504}, // Conc=0.3 - {0.000, 0.000, 0.000, 0.371, 0.377, 0.383, 0.389, 0.395, 0.400, 0.405, 0.410, 0.415, 0.419, 0.424, 0.428, 0.431, 0.435, - 0.438, 0.441, 0.444, 0.446, 0.449, 0.451, 0.452, 0.454, 0.455, 0.456, 0.457, 0.458, 0.458, 0.458, 0.458, 0.458}, // Conc=0.4 - {0.328, 0.333, 0.339, 0.344, 0.349, 0.354, 0.359, 0.364, 0.368, 0.373, 0.377, 0.380, 0.384, 0.387, 0.391, 0.394, 0.397, - 0.399, 0.402, 0.404, 0.406, 0.408, 0.410, 0.411, 0.413, 0.414, 0.415, 0.416, 0.416, 0.417, 0.417, 0.417, 0.417}, // Conc=0.5 - {0.307, 0.312, 0.316, 0.321, 0.325, 0.329, 0.333, 0.336, 0.340, 0.343, 0.346, 0.349, 0.352, 0.355, 0.358, 0.360, 0.363, - 0.365, 0.367, 0.369, 0.371, 0.372, 0.374, 0.375, 0.376, 0.377, 0.378, 0.379, 0.379, 0.380, 0.380, 0.380, 0.380}, // Conc=0.6 - {0.289, 0.293, 0.296, 0.300, 0.303, 0.306, 0.309, 0.312, 0.314, 0.317, 0.320, 0.322, 0.324, 0.327, 0.329, 0.331, 0.332, - 0.334, 0.336, 0.337, 0.339, 0.340, 0.341, 0.342, 0.343, 0.344, 0.345, 0.346, 0.346, 0.347, 0.347, 0.347, 0.347}, // Conc=0.7 - {0.274, 0.276, 0.279, 0.281, 0.283, 0.286, 0.288, 0.290, 0.292, 0.294, 0.296, 0.298, 0.299, 0.301, 0.303, 0.304, 0.306, - 0.307, 0.308, 0.310, 0.311, 0.312, 0.313, 0.314, 0.314, 0.315, 0.316, 0.316, 0.317, 0.317, 0.318, 0.318, 0.318}, // Conc=0.8 - {0.000, 0.000, 0.263, 0.265, 0.266, 0.268, 0.269, 0.271, 0.272, 0.274, 0.275, 0.276, 0.278, 0.279, 0.280, 0.281, 0.282, - 0.283, 0.284, 0.285, 0.286, 0.287, 0.288, 0.288, 0.289, 0.290, 0.290, 0.291, 0.291, 0.292, 0.292, 0.293, 0.293}} // Conc=0.9 + static constexpr std:: + array, DefaultNumGlyConcs> + DefaultEthGlyCondData = + { + {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.5705, 0.58, 0.5893, + 0.5984, 0.6072, 0.6155, 0.6233, 0.6306, 0.6373, 0.6436, 0.6492, 0.6543, 0.659, 0.6631, + 0.6668, 0.67, 0.6728, 0.6753, 0.6773, 0.6791, 0.0, 0.0, 0.0, 0.0, 0.0}, // DefaultWaterCondData + {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.511, 0.520, 0.528, 0.537, 0.545, 0.552, 0.559, 0.566, 0.572, 0.577, + 0.583, 0.588, 0.592, 0.596, 0.600, 0.603, 0.606, 0.608, 0.610, 0.612, 0.613, 0.614, 0.614, 0.614, 0.613, 0.612}, // Conc=0.1 + {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.460, 0.468, 0.476, 0.483, 0.490, 0.497, 0.503, 0.509, 0.515, 0.520, 0.525, + 0.529, 0.534, 0.538, 0.541, 0.544, 0.547, 0.549, 0.551, 0.553, 0.555, 0.556, 0.556, 0.557, 0.557, 0.556, 0.555}, // Conc=0.2 + {0.000, 0.000, 0.000, 0.000, 0.000, 0.415, 0.422, 0.429, 0.436, 0.442, 0.448, 0.453, 0.459, 0.464, 0.469, 0.473, 0.477, + 0.481, 0.485, 0.488, 0.491, 0.494, 0.496, 0.498, 0.500, 0.501, 0.503, 0.504, 0.504, 0.505, 0.505, 0.504, 0.504}, // Conc=0.3 + {0.000, 0.000, 0.000, 0.371, 0.377, 0.383, 0.389, 0.395, 0.400, 0.405, 0.410, 0.415, 0.419, 0.424, 0.428, 0.431, 0.435, + 0.438, 0.441, 0.444, 0.446, 0.449, 0.451, 0.452, 0.454, 0.455, 0.456, 0.457, 0.458, 0.458, 0.458, 0.458, 0.458}, // Conc=0.4 + {0.328, 0.333, 0.339, 0.344, 0.349, 0.354, 0.359, 0.364, 0.368, 0.373, 0.377, 0.380, 0.384, 0.387, 0.391, 0.394, 0.397, + 0.399, 0.402, 0.404, 0.406, 0.408, 0.410, 0.411, 0.413, 0.414, 0.415, 0.416, 0.416, 0.417, 0.417, 0.417, 0.417}, // Conc=0.5 + {0.307, 0.312, 0.316, 0.321, 0.325, 0.329, 0.333, 0.336, 0.340, 0.343, 0.346, 0.349, 0.352, 0.355, 0.358, 0.360, 0.363, + 0.365, 0.367, 0.369, 0.371, 0.372, 0.374, 0.375, 0.376, 0.377, 0.378, 0.379, 0.379, 0.380, 0.380, 0.380, 0.380}, // Conc=0.6 + {0.289, 0.293, 0.296, 0.300, 0.303, 0.306, 0.309, 0.312, 0.314, 0.317, 0.320, 0.322, 0.324, 0.327, 0.329, 0.331, 0.332, + 0.334, 0.336, 0.337, 0.339, 0.340, 0.341, 0.342, 0.343, 0.344, 0.345, 0.346, 0.346, 0.347, 0.347, 0.347, 0.347}, // Conc=0.7 + {0.274, 0.276, 0.279, 0.281, 0.283, 0.286, 0.288, 0.290, 0.292, 0.294, 0.296, 0.298, 0.299, 0.301, 0.303, 0.304, 0.306, + 0.307, 0.308, 0.310, 0.311, 0.312, 0.313, 0.314, 0.314, 0.315, 0.316, 0.316, 0.317, 0.317, 0.318, 0.318, 0.318}, // Conc=0.8 + {0.000, 0.000, 0.263, 0.265, 0.266, 0.268, 0.269, 0.271, 0.272, 0.274, 0.275, 0.276, 0.278, 0.279, 0.280, 0.281, 0.282, + 0.283, 0.284, 0.285, 0.286, 0.287, 0.288, 0.288, 0.289, 0.290, 0.290, 0.291, 0.291, 0.292, 0.292, 0.293, 0.293}} // Conc=0.9 }; - + // Propylene Glycol Data: Specific Heat in J/(kg-k) static constexpr std::array, DefaultNumGlyConcs> DefaultPropGlyCpData = { - {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, - 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, - 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData in J/kg-K - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4042.0, 4050.0, 4058.0, 4067.0, - 4075.0, 4083.0, 4091.0, 4099.0, 4107.0, 4115.0, 4123.0, 4131.0, 4139.0, 4147.0, 4155.0, - 4163.0, 4171.0, 4179.0, 4187.0, 4195.0, 4203.0, 4211.0, 4219.0, 4227.0, 4235.0, 4243.0}, // Conc=0.1 - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3918.0, 3929.0, 3940.0, 3951.0, 3962.0, - 3973.0, 3983.0, 3994.0, 4005.0, 4016.0, 4027.0, 4038.0, 4049.0, 4060.0, 4071.0, 4082.0, - 4093.0, 4104.0, 4115.0, 4126.0, 4136.0, 4147.0, 4158.0, 4169.0, 4180.0, 4191.0, 4202.0}, // Conc=0.2 - {0.0, 0.0, 0.0, 0.0, 0.0, 3765.0, 3779.0, 3793.0, 3807.0, 3820.0, 3834.0, - 3848.0, 3862.0, 3875.0, 3889.0, 3903.0, 3917.0, 3930.0, 3944.0, 3958.0, 3972.0, 3985.0, - 3999.0, 4013.0, 4027.0, 4040.0, 4054.0, 4068.0, 4082.0, 4095.0, 4109.0, 4123.0, 4137.0}, // Conc=0.3 - {0.0, 0.0, 0.0, 0.0, 3586.0, 3603.0, 3619.0, 3636.0, 3652.0, 3669.0, 3685.0, - 3702.0, 3718.0, 3735.0, 3751.0, 3768.0, 3784.0, 3801.0, 3817.0, 3834.0, 3850.0, 3867.0, - 3883.0, 3900.0, 3916.0, 3933.0, 3949.0, 3966.0, 3982.0, 3999.0, 4015.0, 4032.0, 4049.0}, // Conc=0.4 - {0.0, 0.0, 3358.0, 3378.0, 3397.0, 3416.0, 3435.0, 3455.0, 3474.0, 3493.0, 3513.0, - 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, 3648.0, 3667.0, 3686.0, 3706.0, 3725.0, - 3744.0, 3763.0, 3783.0, 3802.0, 3821.0, 3841.0, 3860.0, 3879.0, 3898.0, 3918.0, 3937.0}, // Conc=0.5 - {3096.0, 3118.0, 3140.0, 3162.0, 3184.0, 3206.0, 3228.0, 3250.0, 3272.0, 3295.0, 3317.0, - 3339.0, 3361.0, 3383.0, 3405.0, 3427.0, 3449.0, 3471.0, 3493.0, 3515.0, 3537.0, 3559.0, - 3581.0, 3603.0, 3625.0, 3647.0, 3670.0, 3692.0, 3714.0, 3736.0, 3758.0, 3780.0, 3802.0}, // Conc=0.6 - {2843.0, 2868.0, 2893.0, 2918.0, 2943.0, 2968.0, 2993.0, 3018.0, 3042.0, 3067.0, 3092.0, - 3117.0, 3142.0, 3167.0, 3192.0, 3217.0, 3242.0, 3266.0, 3291.0, 3316.0, 3341.0, 3366.0, - 3391.0, 3416.0, 3441.0, 3465.0, 3490.0, 3515.0, 3540.0, 3565.0, 3590.0, 3615.0, 3640.0}, // Conc=0.7 - {2572.0, 2600.0, 2627.0, 2655.0, 2683.0, 2710.0, 2738.0, 2766.0, 2793.0, 2821.0, 2849.0, - 2876.0, 2904.0, 2931.0, 2959.0, 2987.0, 3014.0, 3042.0, 3070.0, 3097.0, 3125.0, 3153.0, - 3180.0, 3208.0, 3236.0, 3263.0, 3291.0, 3319.0, 3346.0, 3374.0, 3402.0, 3429.0, 3457.0}, // Conc=0.8 - {2264.0, 2295.0, 2326.0, 2356.0, 2387.0, 2417.0, 2448.0, 2478.0, 2509.0, 2539.0, 2570.0, - 2600.0, 2631.0, 2661.0, 2692.0, 2723.0, 2753.0, 2784.0, 2814.0, 2845.0, 2875.0, 2906.0, - 2936.0, 2967.0, 2997.0, 3028.0, 3058.0, 3089.0, 3119.0, 3150.0, 3181.0, 3211.0, 3242.0}} // Conc=0.9 + {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, + 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData + // in + // J/kg-K + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4042.0, 4050.0, 4058.0, 4067.0, 4075.0, 4083.0, 4091.0, 4099.0, 4107.0, 4115.0, + 4123.0, 4131.0, 4139.0, 4147.0, 4155.0, 4163.0, 4171.0, 4179.0, 4187.0, 4195.0, 4203.0, 4211.0, 4219.0, 4227.0, 4235.0, 4243.0}, // Conc=0.1 + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3918.0, 3929.0, 3940.0, 3951.0, 3962.0, 3973.0, 3983.0, 3994.0, 4005.0, 4016.0, 4027.0, + 4038.0, 4049.0, 4060.0, 4071.0, 4082.0, 4093.0, 4104.0, 4115.0, 4126.0, 4136.0, 4147.0, 4158.0, 4169.0, 4180.0, 4191.0, 4202.0}, // Conc=0.2 + {0.0, 0.0, 0.0, 0.0, 0.0, 3765.0, 3779.0, 3793.0, 3807.0, 3820.0, 3834.0, 3848.0, 3862.0, 3875.0, 3889.0, 3903.0, 3917.0, + 3930.0, 3944.0, 3958.0, 3972.0, 3985.0, 3999.0, 4013.0, 4027.0, 4040.0, 4054.0, 4068.0, 4082.0, 4095.0, 4109.0, 4123.0, 4137.0}, // Conc=0.3 + {0.0, 0.0, 0.0, 0.0, 3586.0, 3603.0, 3619.0, 3636.0, 3652.0, 3669.0, 3685.0, 3702.0, 3718.0, 3735.0, 3751.0, 3768.0, 3784.0, + 3801.0, 3817.0, 3834.0, 3850.0, 3867.0, 3883.0, 3900.0, 3916.0, 3933.0, 3949.0, 3966.0, 3982.0, 3999.0, 4015.0, 4032.0, 4049.0}, // Conc=0.4 + {0.0, 0.0, 3358.0, 3378.0, 3397.0, 3416.0, 3435.0, 3455.0, 3474.0, 3493.0, 3513.0, 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, + 3648.0, 3667.0, 3686.0, 3706.0, 3725.0, 3744.0, 3763.0, 3783.0, 3802.0, 3821.0, 3841.0, 3860.0, 3879.0, 3898.0, 3918.0, 3937.0}, // Conc=0.5 + {3096.0, 3118.0, 3140.0, 3162.0, 3184.0, 3206.0, 3228.0, 3250.0, 3272.0, 3295.0, 3317.0, 3339.0, 3361.0, 3383.0, 3405.0, 3427.0, 3449.0, + 3471.0, 3493.0, 3515.0, 3537.0, 3559.0, 3581.0, 3603.0, 3625.0, 3647.0, 3670.0, 3692.0, 3714.0, 3736.0, 3758.0, 3780.0, 3802.0}, // Conc=0.6 + {2843.0, 2868.0, 2893.0, 2918.0, 2943.0, 2968.0, 2993.0, 3018.0, 3042.0, 3067.0, 3092.0, 3117.0, 3142.0, 3167.0, 3192.0, 3217.0, 3242.0, + 3266.0, 3291.0, 3316.0, 3341.0, 3366.0, 3391.0, 3416.0, 3441.0, 3465.0, 3490.0, 3515.0, 3540.0, 3565.0, 3590.0, 3615.0, 3640.0}, // Conc=0.7 + {2572.0, 2600.0, 2627.0, 2655.0, 2683.0, 2710.0, 2738.0, 2766.0, 2793.0, 2821.0, 2849.0, 2876.0, 2904.0, 2931.0, 2959.0, 2987.0, 3014.0, + 3042.0, 3070.0, 3097.0, 3125.0, 3153.0, 3180.0, 3208.0, 3236.0, 3263.0, 3291.0, 3319.0, 3346.0, 3374.0, 3402.0, 3429.0, 3457.0}, // Conc=0.8 + {2264.0, 2295.0, 2326.0, 2356.0, 2387.0, 2417.0, 2448.0, 2478.0, 2509.0, 2539.0, 2570.0, 2600.0, 2631.0, 2661.0, 2692.0, 2723.0, 2753.0, + 2784.0, 2814.0, 2845.0, 2875.0, 2906.0, 2936.0, 2967.0, 2997.0, 3028.0, 3058.0, 3089.0, 3119.0, 3150.0, 3181.0, 3211.0, 3242.0}} // Conc=0.9 }; // Propylene Glycol Data: Viscosity in mPa-s @@ -311,7 +306,7 @@ namespace FluidProperties { 4.9e-04, 4.6e-04, 4.3e-04, 4.0e-04, 3.8e-04, 3.5e-04, 3.3e-04, 3.2e-04, 3.0e-04, 2.8e-04, 2.7e-04}, // Conc=0.1 {0.0e+00, 0.0e+00, 0.0e+00, 0.0e+00, 0.0e+00, 0.0e+00, 4.98e-03, 4.05e-03, 3.34e-03, 2.79e-03, 2.36e-03, 2.02e-03, 1.74e-03, 1.52e-03, 1.34e-03, 1.18e-03, 1.06e-03, 9.5e-04, 8.6e-04, 7.8e-04, 7.1e-04, 6.6e-04, - 6.0e-04, 5.6e-04, 5.2e-04, 4.9e-04, 4.5e-04, 4.3e-04, 4.0e-04, 3.8e-04, 3.6e-04, 3.4e-04, 3.2e-04}, // Conc=0.2 + 6.0e-04, 5.6e-04, 5.2e-04, 4.9e-04, 4.5e-04, 4.3e-04, 4.0e-04, 3.8e-04, 3.6e-04, 3.4e-04, 3.2e-04}, // Conc=0.2 {0.0e+00, 0.0e+00, 0.0e+00, 0.0e+00, 0.0e+00, 1.187e-02, 9.08e-03, 7.08e-03, 5.61e-03, 4.52e-03, 3.69e-03, 3.06e-03, 2.57e-03, 2.18e-03, 1.88e-03, 1.63e-03, 1.43e-03, 1.26e-03, 1.13e-03, 1.01e-03, 9.1e-04, 8.3e-04, 7.6e-04, 7.0e-04, 6.5e-04, 6.1e-04, 5.7e-04, 5.3e-04, 5.0e-04, 4.7e-04, 4.5e-04, 4.3e-04, 4.1e-04}, // Conc=0.3 @@ -327,17 +322,16 @@ namespace FluidProperties { {9.1618e-01, 5.5112e-01, 3.4009e-01, 2.1567e-01, 1.4062e-01, 9.423e-02, 6.483e-02, 4.574e-02, 3.304e-02, 2.441e-02, 1.841e-02, 1.415e-02, 1.108e-02, 8.81e-03, 7.12e-03, 5.84e-03, 4.85e-03, 4.08e-03, 3.46e-03, 2.98e-03, 2.58e-03, 2.26e-03, 1.99e-03, 1.77e-03, 1.59e-03, 1.43e-03, 1.30e-03, 1.18e-03, 1.08e-03, 1.00e-03, 9.3e-04, 8.6e-04, 8.0e-04}, // Conc=0.7 - {1.43422e+00, 9.0847e-01, 5.7592e-01, 3.6877e-01, 2.3986e-01, 1.5902e-01, 1.0764e-01, 7.445e-02, 5.263e-02, - 3.799e-02, 2.800e-02, 2.104e-02, 1.610e-02, 1.255e-02, 9.94e-03, 7.99e-03, 6.52e-03, 5.39e-03, - 4.51e-03, 3.82e-03, 3.28e-03, 2.83e-03, 2.47e-03, 2.18e-03, 1.94e-03, 1.73e-03, 1.56e-03, - 1.42e-03, 1.29e-03, 1.19e-03, 1.09e-03, 1.02e-03, 9.5e-04}, // Conc=0.8 + {1.43422e+00, 9.0847e-01, 5.7592e-01, 3.6877e-01, 2.3986e-01, 1.5902e-01, 1.0764e-01, 7.445e-02, 5.263e-02, 3.799e-02, 2.800e-02, + 2.104e-02, 1.610e-02, 1.255e-02, 9.94e-03, 7.99e-03, 6.52e-03, 5.39e-03, 4.51e-03, 3.82e-03, 3.28e-03, 2.83e-03, + 2.47e-03, 2.18e-03, 1.94e-03, 1.73e-03, 1.56e-03, 1.42e-03, 1.29e-03, 1.19e-03, 1.09e-03, 1.02e-03, 9.5e-04}, // Conc=0.8 {3.81329e+00, 2.07134e+00, 1.17609e+00, 6.9609e-01, 4.2819e-01, 2.7294e-01, 1.7978e-01, 1.2203e-01, 8.515e-02, 6.093e-02, 4.462e-02, 3.338e-02, 2.545e-02, 1.976e-02, 1.560e-02, 1.249e-02, 1.015e-02, 8.35e-03, 6.95e-03, 5.85e-03, 4.97e-03, 4.26e-03, 3.69e-03, 3.22e-03, 2.83e-03, 2.50e-03, 2.23e-03, 2.00e-03, 1.80e-03, 1.63e-03, 1.48e-03, 1.35e-03, 1.24e-03}} // Conc=0.9 }; - - // Propylene Glycol Data: Density in kg/m3 + + // Propylene Glycol Data: Density in kg/m3 static constexpr std::array, DefaultNumGlyConcs> DefaultPropGlyRhoData = { {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 999.8, 999.9, 999.7, 999.1, 998.2, 997.0, 995.6, 994.0, 992.2, 990.2, 988.0, 985.7, 983.2, 980.5, 977.7, 974.8, 971.8, 968.6, 965.3, 961.9, 958.3, 0.0, 0.0, 0.0, 0.0, 0.0}, // DefaultWaterRhoData in @@ -372,29 +366,32 @@ namespace FluidProperties { }; // Propylene Glycol Data: Conductivity in W/(m-K) - static constexpr std::array, DefaultNumGlyConcs> DefaultPropGlyCondData = { - {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.5705, 0.58, 0.5893, - 0.5984, 0.6072, 0.6155, 0.6233, 0.6306, 0.6373, 0.6436, 0.6492, 0.6543, 0.659, 0.6631, - 0.6668, 0.67, 0.6728, 0.6753, 0.6773, 0.6791, 0.0, 0.0, 0.0, 0.0, 0.0}, // DefaultWaterCondData - // in W/mK - {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.510, 0.518, 0.527, 0.535, 0.543, 0.550, 0.557, 0.563, 0.569, 0.575, - 0.580, 0.585, 0.589, 0.593, 0.596, 0.599, 0.602, 0.604, 0.606, 0.607, 0.608, 0.609, 0.609, 0.608, 0.608, 0.606}, // Conc=0.1 - {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.456, 0.464, 0.472, 0.479, 0.485, 0.492, 0.498, 0.503, 0.508, 0.513, 0.518, - 0.522, 0.526, 0.529, 0.532, 0.535, 0.538, 0.540, 0.541, 0.543, 0.544, 0.544, 0.544, 0.544, 0.544, 0.543, 0.542}, // Conc=0.2 - {0.000, 0.000, 0.000, 0.000, 0.000, 0.410, 0.416, 0.423, 0.429, 0.434, 0.440, 0.445, 0.449, 0.454, 0.458, 0.462, 0.466, - 0.469, 0.472, 0.475, 0.477, 0.479, 0.481, 0.482, 0.484, 0.484, 0.485, 0.485, 0.485, 0.485, 0.485, 0.484, 0.482}, // Conc=0.3 - {0.000, 0.000, 0.000, 0.000, 0.369, 0.375, 0.380, 0.385, 0.389, 0.394, 0.398, 0.402, 0.406, 0.409, 0.412, 0.415, 0.418, - 0.420, 0.423, 0.425, 0.426, 0.428, 0.429, 0.430, 0.431, 0.431, 0.432, 0.432, 0.432, 0.431, 0.430, 0.429, 0.428}, // Conc=0.4 - {0.000, 0.000, 0.329, 0.334, 0.338, 0.342, 0.346, 0.349, 0.353, 0.356, 0.359, 0.362, 0.365, 0.367, 0.370, 0.372, 0.374, - 0.375, 0.377, 0.378, 0.379, 0.380, 0.381, 0.382, 0.382, 0.382, 0.382, 0.382, 0.382, 0.381, 0.380, 0.379, 0.378}, // Conc=0.5 - {0.296, 0.300, 0.303, 0.306, 0.309, 0.312, 0.314, 0.317, 0.319, 0.321, 0.323, 0.325, 0.327, 0.329, 0.330, 0.331, 0.333, - 0.334, 0.335, 0.335, 0.336, 0.336, 0.337, 0.337, 0.337, 0.337, 0.336, 0.336, 0.335, 0.335, 0.334, 0.333, 0.332}, // Conc=0.6 - {0.275, 0.277, 0.278, 0.280, 0.282, 0.284, 0.285, 0.286, 0.289, 0.290, 0.291, 0.292, 0.293, 0.293, 0.294, 0.294, 0.295, - 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.294, 0.294, 0.293, 0.292, 0.292, 0.291, 0.290, 0.288}, // Conc=0.7 - {0.255, 0.256, 0.257, 0.257, 0.258, 0.259, 0.259, 0.259, 0.260, 0.260, 0.260, 0.261, 0.261, 0.261, 0.261, 0.261, 0.260, - 0.260, 0.260, 0.260, 0.259, 0.259, 0.258, 0.258, 0.257, 0.256, 0.256, 0.255, 0.254, 0.253, 0.252, 0.251, 0.250}, // Conc=0.8 - {0.237, 0.237, 0.236, 0.236, 0.236, 0.235, 0.235, 0.234, 0.234, 0.233, 0.233, 0.232, 0.233, 0.231, 0.230, 0.229, 0.229, - 0.228, 0.227, 0.227, 0.226, 0.225, 0.224, 0.223, 0.222, 0.221, 0.220, 0.219, 0.218, 0.217, 0.216, 0.215, 0.214}} // Conc=0.9 + static constexpr std:: + array, DefaultNumGlyConcs> + DefaultPropGlyCondData = + { + {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.5705, 0.58, 0.5893, + 0.5984, 0.6072, 0.6155, 0.6233, 0.6306, 0.6373, 0.6436, 0.6492, 0.6543, 0.659, 0.6631, + 0.6668, 0.67, 0.6728, 0.6753, 0.6773, 0.6791, 0.0, 0.0, 0.0, 0.0, 0.0}, // DefaultWaterCondData + // in W/mK + {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.510, 0.518, 0.527, 0.535, 0.543, 0.550, 0.557, 0.563, 0.569, 0.575, + 0.580, 0.585, 0.589, 0.593, 0.596, 0.599, 0.602, 0.604, 0.606, 0.607, 0.608, 0.609, 0.609, 0.608, 0.608, 0.606}, // Conc=0.1 + {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.456, 0.464, 0.472, 0.479, 0.485, 0.492, 0.498, 0.503, 0.508, 0.513, 0.518, + 0.522, 0.526, 0.529, 0.532, 0.535, 0.538, 0.540, 0.541, 0.543, 0.544, 0.544, 0.544, 0.544, 0.544, 0.543, 0.542}, // Conc=0.2 + {0.000, 0.000, 0.000, 0.000, 0.000, 0.410, 0.416, 0.423, 0.429, 0.434, 0.440, 0.445, 0.449, 0.454, 0.458, 0.462, 0.466, + 0.469, 0.472, 0.475, 0.477, 0.479, 0.481, 0.482, 0.484, 0.484, 0.485, 0.485, 0.485, 0.485, 0.485, 0.484, 0.482}, // Conc=0.3 + {0.000, 0.000, 0.000, 0.000, 0.369, 0.375, 0.380, 0.385, 0.389, 0.394, 0.398, 0.402, 0.406, 0.409, 0.412, 0.415, 0.418, + 0.420, 0.423, 0.425, 0.426, 0.428, 0.429, 0.430, 0.431, 0.431, 0.432, 0.432, 0.432, 0.431, 0.430, 0.429, 0.428}, // Conc=0.4 + {0.000, 0.000, 0.329, 0.334, 0.338, 0.342, 0.346, 0.349, 0.353, 0.356, 0.359, 0.362, 0.365, 0.367, 0.370, 0.372, 0.374, + 0.375, 0.377, 0.378, 0.379, 0.380, 0.381, 0.382, 0.382, 0.382, 0.382, 0.382, 0.382, 0.381, 0.380, 0.379, 0.378}, // Conc=0.5 + {0.296, 0.300, 0.303, 0.306, 0.309, 0.312, 0.314, 0.317, 0.319, 0.321, 0.323, 0.325, 0.327, 0.329, 0.330, 0.331, 0.333, + 0.334, 0.335, 0.335, 0.336, 0.336, 0.337, 0.337, 0.337, 0.337, 0.336, 0.336, 0.335, 0.335, 0.334, 0.333, 0.332}, // Conc=0.6 + {0.275, 0.277, 0.278, 0.280, 0.282, 0.284, 0.285, 0.286, 0.289, 0.290, 0.291, 0.292, 0.293, 0.293, 0.294, 0.294, 0.295, + 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.295, 0.294, 0.294, 0.293, 0.292, 0.292, 0.291, 0.290, 0.288}, // Conc=0.7 + {0.255, 0.256, 0.257, 0.257, 0.258, 0.259, 0.259, 0.259, 0.260, 0.260, 0.260, 0.261, 0.261, 0.261, 0.261, 0.261, 0.260, + 0.260, 0.260, 0.260, 0.259, 0.259, 0.258, 0.258, 0.257, 0.256, 0.256, 0.255, 0.254, 0.253, 0.252, 0.251, 0.250}, // Conc=0.8 + {0.237, 0.237, 0.236, 0.236, 0.236, 0.235, 0.235, 0.234, 0.234, 0.233, 0.233, 0.232, 0.233, 0.231, 0.230, 0.229, 0.229, + 0.228, 0.227, 0.227, 0.226, 0.225, 0.224, 0.223, 0.222, 0.221, 0.220, 0.219, 0.218, 0.217, 0.216, 0.215, 0.214}} // Conc=0.9 }; // Steam Refrigerant Data @@ -404,8 +401,7 @@ namespace FluidProperties { 107.0, 108.0, 109.0, 110.0, 111.0, 112.0, 113.0, 114.0, 115.0, 116.0, 117.0, 118.0, 119.0, 120.0, 121.0, 122.0, 123.0, 124.0, 125.0, 126.0, 127.0, 128.0, 129.0, 130.0, 132.0, 134.0, 136.0, 138.0, 140.0, 142.0, 144.0, 146.0, 148.0, 150.0, 152.0, 154.0, 156.0, 158.0, 160.0, 162.0, 164.0, 166.0, 168.0, 170.0, 172.0, 174.0, 176.0, 178.0, 180.0, 185.0, 190.0, 195.0, 200.0, 205.0, 210.0, 215.0, 220.0, - 225.0, 230.0, 240.0, 250.0, 260.0, 270.0, 280.0, 290.0, 300.0, 310.0, 320.0, 330.0, 340.0, 350.0, 360.0, 370.0 - }; + 225.0, 230.0, 240.0, 250.0, 260.0, 270.0, 280.0, 290.0, 300.0, 310.0, 320.0, 330.0, 340.0, 350.0, 360.0, 370.0}; static constexpr std::array DefaultSteamPressData = { 611.7, 657.1, 872.6, 1228.0, 1706.0, 2339.0, 3170.0, 4247.0, 5629.0, 7385.0, 9595.0, 12350.0, @@ -417,34 +413,29 @@ namespace FluidProperties { 502200.0, 529500.0, 557800.0, 587400.0, 618200.0, 650300.0, 683700.0, 718500.0, 754600.0, 792200.0, 831200.0, 871800.0, 913800.0, 957500.0, 1003000.0, 1123000.0, 1255000.0, 1399000.0, 1555000.0, 1724000.0, 1908000.0, 2106000.0, 2320000.0, 2550000.0, 2797000.0, 3347000.0, 3976000.0, 4692000.0, 5503000.0, 6417000.0, 7442000.0, 8588000.0, 9865000.0, 11280000.0, 12860000.0, 14600000.0, - 16530000.0, 18670000.0, 21040000.0 - }; + 16530000.0, 18670000.0, 21040000.0}; static constexpr std::array DefaultSteamEnthalpyFluidData = { - 0.59, 4177.0, 21020.0, 42020.0, 62980.0, 83910.0, 104800.0, 125700.0, 146600.0, 167500.0, 188400.0, 209300.0, - 230300.0, 251200.0, 272100.0, 293100.0, 301400.0, 309800.0, 318200.0, 326600.0, 335000.0, 343400.0, 351800.0, 360200.0, - 368600.0, 377000.0, 385500.0, 393900.0, 402300.0, 410700.0, 414900.0, 419200.0, 423400.0, 427600.0, 431800.0, 436000.0, - 440300.0, 444500.0, 448700.0, 453000.0, 457200.0, 461400.0, 465600.0, 469900.0, 474100.0, 478400.0, 482600.0, 486800.0, - 491100.0, 495300.0, 499600.0, 503800.0, 508100.0, 512300.0, 516600.0, 520800.0, 525100.0, 529300.0, 533600.0, 537900.0, - 542100.0, 546400.0, 554900.0, 563500.0, 572000.0, 580600.0, 589200.0, 597700.0, 606300.0, 614900.0, 623600.0, 632200.0, - 640800.0, 649500.0, 658100.0, 666800.0, 675500.0, 684200.0, 692900.0, 701600.0, 710300.0, 719100.0, 727800.0, 736600.0, - 745400.0, 754200.0, 763100.0, 785200.0, 807400.0, 829800.0, 852300.0, 874900.0, 897600.0, 920500.0, 943600.0, 966800.0, - 990200.0, 1038000.0, 1086000.0, 1135000.0, 1185000.0, 1237000.0, 1290000.0, 1345000.0, 1402000.0, 1462000.0, 1526000.0, 1595000.0, - 1671000.0, 1762000.0, 1891000.0 - }; - + 0.59, 4177.0, 21020.0, 42020.0, 62980.0, 83910.0, 104800.0, 125700.0, 146600.0, 167500.0, 188400.0, 209300.0, 230300.0, + 251200.0, 272100.0, 293100.0, 301400.0, 309800.0, 318200.0, 326600.0, 335000.0, 343400.0, 351800.0, 360200.0, 368600.0, 377000.0, + 385500.0, 393900.0, 402300.0, 410700.0, 414900.0, 419200.0, 423400.0, 427600.0, 431800.0, 436000.0, 440300.0, 444500.0, 448700.0, + 453000.0, 457200.0, 461400.0, 465600.0, 469900.0, 474100.0, 478400.0, 482600.0, 486800.0, 491100.0, 495300.0, 499600.0, 503800.0, + 508100.0, 512300.0, 516600.0, 520800.0, 525100.0, 529300.0, 533600.0, 537900.0, 542100.0, 546400.0, 554900.0, 563500.0, 572000.0, + 580600.0, 589200.0, 597700.0, 606300.0, 614900.0, 623600.0, 632200.0, 640800.0, 649500.0, 658100.0, 666800.0, 675500.0, 684200.0, + 692900.0, 701600.0, 710300.0, 719100.0, 727800.0, 736600.0, 745400.0, 754200.0, 763100.0, 785200.0, 807400.0, 829800.0, 852300.0, + 874900.0, 897600.0, 920500.0, 943600.0, 966800.0, 990200.0, 1038000.0, 1086000.0, 1135000.0, 1185000.0, 1237000.0, 1290000.0, 1345000.0, + 1402000.0, 1462000.0, 1526000.0, 1595000.0, 1671000.0, 1762000.0, 1891000.0}; + static constexpr std::array DefaultSteamEnthalpyGasFluidData = { - 2501000.0, 2503000.0, 2510000.0, 2519000.0, 2528000.0, 2537000.0, 2547000.0, 2556000.0, 2565000.0, 2574000.0, 2582000.0, 2591000.0, - 2600000.0, 2609000.0, 2618000.0, 2626000.0, 2630000.0, 2633000.0, 2636000.0, 2640000.0, 2643000.0, 2646000.0, 2650000.0, 2653000.0, - 2656000.0, 2660000.0, 2663000.0, 2666000.0, 2669000.0, 2672000.0, 2674000.0, 2676000.0, 2677000.0, 2679000.0, 2680000.0, 2682000.0, - 2683000.0, 2685000.0, 2686000.0, 2688000.0, 2690000.0, 2691000.0, 2693000.0, 2694000.0, 2696000.0, 2697000.0, 2699000.0, 2700000.0, - 2702000.0, 2703000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2710000.0, 2712000.0, 2713000.0, 2715000.0, 2716000.0, 2717000.0, - 2719000.0, 2720000.0, 2723000.0, 2726000.0, 2728000.0, 2731000.0, 2733000.0, 2736000.0, 2739000.0, 2741000.0, 2744000.0, 2746000.0, - 2748000.0, 2751000.0, 2753000.0, 2755000.0, 2757000.0, 2760000.0, 2762000.0, 2764000.0, 2766000.0, 2768000.0, 2770000.0, 2772000.0, - 2774000.0, 2775000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2792000.0, 2795000.0, 2797000.0, 2799000.0, 2801000.0, 2802000.0, - 2803000.0, 2803000.0, 2801000.0, 2797000.0, 2790000.0, 2780000.0, 2767000.0, 2750000.0, 2728000.0, 2701000.0, 2666000.0, 2622000.0, - 2564000.0, 2481000.0, 2335000.0 - }; + 2501000.0, 2503000.0, 2510000.0, 2519000.0, 2528000.0, 2537000.0, 2547000.0, 2556000.0, 2565000.0, 2574000.0, 2582000.0, 2591000.0, 2600000.0, + 2609000.0, 2618000.0, 2626000.0, 2630000.0, 2633000.0, 2636000.0, 2640000.0, 2643000.0, 2646000.0, 2650000.0, 2653000.0, 2656000.0, 2660000.0, + 2663000.0, 2666000.0, 2669000.0, 2672000.0, 2674000.0, 2676000.0, 2677000.0, 2679000.0, 2680000.0, 2682000.0, 2683000.0, 2685000.0, 2686000.0, + 2688000.0, 2690000.0, 2691000.0, 2693000.0, 2694000.0, 2696000.0, 2697000.0, 2699000.0, 2700000.0, 2702000.0, 2703000.0, 2704000.0, 2706000.0, + 2707000.0, 2709000.0, 2710000.0, 2712000.0, 2713000.0, 2715000.0, 2716000.0, 2717000.0, 2719000.0, 2720000.0, 2723000.0, 2726000.0, 2728000.0, + 2731000.0, 2733000.0, 2736000.0, 2739000.0, 2741000.0, 2744000.0, 2746000.0, 2748000.0, 2751000.0, 2753000.0, 2755000.0, 2757000.0, 2760000.0, + 2762000.0, 2764000.0, 2766000.0, 2768000.0, 2770000.0, 2772000.0, 2774000.0, 2775000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2792000.0, + 2795000.0, 2797000.0, 2799000.0, 2801000.0, 2802000.0, 2803000.0, 2803000.0, 2801000.0, 2797000.0, 2790000.0, 2780000.0, 2767000.0, 2750000.0, + 2728000.0, 2701000.0, 2666000.0, 2622000.0, 2564000.0, 2481000.0, 2335000.0}; static constexpr std::array DefaultSteamCpFluidData = { 4220.0, 4217.0, 4205.0, 4196.0, 4189.0, 4184.0, 4182.0, 4180.0, 4180.0, 4180.0, 4180.0, 4182.0, 4183.0, 4185.0, 4187.0, 4190.0, @@ -453,8 +444,7 @@ namespace FluidProperties { 4239.0, 4240.0, 4242.0, 4244.0, 4245.0, 4247.0, 4249.0, 4250.0, 4252.0, 4254.0, 4256.0, 4258.0, 4260.0, 4261.0, 4265.0, 4270.0, 4274.0, 4278.0, 4283.0, 4287.0, 4292.0, 4297.0, 4302.0, 4307.0, 4312.0, 4318.0, 4324.0, 4329.0, 4335.0, 4341.0, 4348.0, 4354.0, 4361.0, 4368.0, 4375.0, 4382.0, 4390.0, 4397.0, 4405.0, 4425.0, 4447.0, 4471.0, 4496.0, 4523.0, 4551.0, 4582.0, 4615.0, 4650.0, - 4688.0, 4772.0, 4870.0, 4986.0, 5123.0, 5289.0, 5493.0, 5750.0, 6085.0, 6537.0, 7186.0, 8208.0, 10120.0, 15000.0, 45160.0 - }; + 4688.0, 4772.0, 4870.0, 4986.0, 5123.0, 5289.0, 5493.0, 5750.0, 6085.0, 6537.0, 7186.0, 8208.0, 10120.0, 15000.0, 45160.0}; static constexpr std::array DefaultSteamCpGasFluidData = { 1884.0, 1885.0, 1889.0, 1895.0, 1900.0, 1906.0, 1912.0, 1918.0, 1925.0, 1931.0, 1939.0, 1947.0, 1955.0, 1965.0, 1975.0, 1986.0, @@ -463,18 +453,16 @@ namespace FluidProperties { 2160.0, 2166.0, 2171.0, 2177.0, 2183.0, 2189.0, 2195.0, 2201.0, 2207.0, 2213.0, 2219.0, 2226.0, 2232.0, 2239.0, 2252.0, 2266.0, 2281.0, 2296.0, 2311.0, 2327.0, 2343.0, 2359.0, 2376.0, 2394.0, 2412.0, 2430.0, 2449.0, 2468.0, 2488.0, 2509.0, 2529.0, 2551.0, 2572.0, 2594.0, 2617.0, 2640.0, 2664.0, 2688.0, 2713.0, 2777.0, 2844.0, 2915.0, 2990.0, 3068.0, 3150.0, 3237.0, 3329.0, 3426.0, - 3528.0, 3754.0, 4011.0, 4308.0, 4656.0, 5073.0, 5582.0, 6220.0, 7045.0, 8159.0, 9753.0, 12240.0, 16690.0, 27360.0, 96600.0 - }; - + 3528.0, 3754.0, 4011.0, 4308.0, 4656.0, 5073.0, 5582.0, 6220.0, 7045.0, 8159.0, 9753.0, 12240.0, 16690.0, 27360.0, 96600.0}; + static constexpr std::array DefaultSteamDensityFluidData = { 999.8, 999.9, 999.9, 999.7, 999.1, 998.2, 997.0, 995.6, 994.0, 992.2, 990.2, 988.0, 985.7, 983.2, 980.5, 977.7, 976.6, 975.4, 974.2, 973.0, 971.8, 970.5, 969.2, 967.9, 966.6, 965.3, 963.9, 962.6, 961.2, 959.8, 959.1, 958.3, 957.6, 956.9, 956.2, 955.4, 954.7, 954.0, 953.2, 952.5, 951.7, 950.9, 950.2, 949.4, 948.6, 947.9, 947.1, 946.3, 945.5, 944.7, 943.9, 943.1, 942.3, 941.5, 940.7, 939.8, 939.0, 938.2, 937.4, 936.5, 935.7, 934.8, 933.1, 931.4, 929.7, 927.9, 926.1, 924.3, 922.5, 920.7, 918.9, 917.0, 915.1, 913.2, 911.3, 909.4, 907.4, 905.5, 903.5, 901.5, 899.5, 897.5, 895.4, 893.3, 891.2, 889.1, 887.0, 881.6, 876.1, 870.4, 864.7, 858.8, 852.7, 846.5, 840.2, - 833.7, 827.1, 813.4, 798.9, 783.6, 767.5, 750.3, 731.9, 712.1, 690.7, 667.1, 640.8, 610.7, 574.7, 527.6, 451.4 - }; - + 833.7, 827.1, 813.4, 798.9, 783.6, 767.5, 750.3, 731.9, 712.1, 690.7, 667.1, 640.8, 610.7, 574.7, 527.6, 451.4}; + static constexpr std::array DefaultSteamDensityGasFluidData = { 4.86e-003, 5.20e-003, 6.80e-003, 9.41e-003, 1.28e-002, 1.73e-002, 2.31e-002, 3.04e-002, 3.97e-002, 5.12e-002, 6.56e-002, 8.32e-002, 0.10, 0.13, 0.16, 0.20, 0.22, 0.23, 0.25, 0.27, 0.29, 0.32, 0.34, 0.37, 0.39, 0.42, @@ -484,32 +472,28 @@ namespace FluidProperties { 1.86, 1.97, 2.07, 2.19, 2.30, 2.42, 2.55, 2.68, 2.82, 2.96, 3.11, 3.26, 3.42, 3.59, 3.76, 3.94, 4.12, 4.32, 4.52, 4.72, 4.94, 5.16, 5.75, 6.40, 7.10, 7.86, 8.69, 9.59, 10.56, 11.62, 12.75, 13.99, 16.75, 19.97, 23.71, 28.07, 33.16, 39.13, 46.17, - 54.54, 64.64, 77.05, 92.76, 113.60, 143.90, 201.80 - }; - + 54.54, 64.64, 77.05, 92.76, 113.60, 143.90, 201.80}; + static constexpr std::array DefaultSteamSuperheatedTemps = { 1.00e-002, 1.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 72.0, 74.0, 76.0, 78.0, 80.0, 82.0, 84.0, 86.0, 88.0, 90.0, 92.0, 94.0, 96.0, 98.0, 99.0, 100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0, 108.0, 109.0, 110.0, 111.0, 112.0, 113.0, 114.0, 115.0, 116.0, 117.0, 118.0, 119.0, 120.0, 121.0, 122.0, 123.0, 124.0, 125.0, 126.0, 127.0, 128.0, 129.0, 130.0, 132.0, 134.0, 136.0, 138.0, 140.0, 142.0, 144.0, 146.0, 148.0, 150.0, 152.0, 154.0, 156.0, 158.0, 160.0, 162.0, 164.0, 166.0, 168.0, 170.0, 172.0, 174.0, 176.0, 178.0, 180.0, 185.0, 190.0, 195.0, 200.0, 205.0, 210.0, 215.0, 220.0, - 225.0, 230.0, 240.0, 250.0, 260.0, 270.0, 280.0, 290.0, 300.0, 310.0, 320.0, 330.0, 340.0, 350.0, 360.0, 370.0, 400.0, 450.0, 500.0 - }; + 225.0, 230.0, 240.0, 250.0, 260.0, 270.0, 280.0, 290.0, 300.0, 310.0, 320.0, 330.0, 340.0, 350.0, 360.0, 370.0, 400.0, 450.0, 500.0}; static constexpr std::array DefaultSteamSuperheatedPressData = { - 611.70, 657.10, 872.60, 1228.0, 1706.0, 2339.0, 3170.0, 4247.0, 5629.0, 7385.0, 9595.0, - 12350.0, 15760.0, 19950.0, 25040.0, 31200.0, 34000.0, 37010.0, 40240.0, 43700.0, 47410.0, 51390.0, - 55640.0, 60170.0, 65020.0, 70180.0, 75680.0, 81540.0, 87770.0, 94390.0, 97850.0, 101400.0, 105100.0, - 108900.0, 112800.0, 116800.0, 120900.0, 125100.0, 129500.0, 134000.0, 138600.0, 143400.0, 148300.0, 153300.0, - 158400.0, 163700.0, 169200.0, 174800.0, 180500.0, 186400.0, 192500.0, 198700.0, 205000.0, 211600.0, 218300.0, - 225200.0, 232200.0, 239500.0, 246900.0, 254500.0, 262300.0, 270300.0, 286800.0, 304200.0, 322400.0, 341500.0, - 361500.0, 382500.0, 404400.0, 427300.0, 451200.0, 476200.0, 502200.0, 529500.0, 557800.0, 587400.0, 618200.0, - 650300.0, 683700.0, 718500.0, 754600.0, 792200.0, 831200.0, 871800.0, 913800.0, 957500.0, 1003000.0, 1123000.0, - 1255000.0, 1399000.0, 1555000.0, 1724000.0, 1908000.0, 2106000.0, 2320000.0, 2550000.0, 2797000.0, 3347000.0, 3976000.0, - 4692000.0, 5503000.0, 6417000.0, 7442000.0, 8588000.0, 9865000.0, 11280000.0, 12860000.0, 14600000.0, 16530000.0, 18670000.0, - 21040000.0, 30000000.0, 35000000.0, 40000000.0 - }; - + 611.70, 657.10, 872.60, 1228.0, 1706.0, 2339.0, 3170.0, 4247.0, 5629.0, 7385.0, 9595.0, 12350.0, + 15760.0, 19950.0, 25040.0, 31200.0, 34000.0, 37010.0, 40240.0, 43700.0, 47410.0, 51390.0, 55640.0, 60170.0, + 65020.0, 70180.0, 75680.0, 81540.0, 87770.0, 94390.0, 97850.0, 101400.0, 105100.0, 108900.0, 112800.0, 116800.0, + 120900.0, 125100.0, 129500.0, 134000.0, 138600.0, 143400.0, 148300.0, 153300.0, 158400.0, 163700.0, 169200.0, 174800.0, + 180500.0, 186400.0, 192500.0, 198700.0, 205000.0, 211600.0, 218300.0, 225200.0, 232200.0, 239500.0, 246900.0, 254500.0, + 262300.0, 270300.0, 286800.0, 304200.0, 322400.0, 341500.0, 361500.0, 382500.0, 404400.0, 427300.0, 451200.0, 476200.0, + 502200.0, 529500.0, 557800.0, 587400.0, 618200.0, 650300.0, 683700.0, 718500.0, 754600.0, 792200.0, 831200.0, 871800.0, + 913800.0, 957500.0, 1003000.0, 1123000.0, 1255000.0, 1399000.0, 1555000.0, 1724000.0, 1908000.0, 2106000.0, 2320000.0, 2550000.0, + 2797000.0, 3347000.0, 3976000.0, 4692000.0, 5503000.0, 6417000.0, 7442000.0, 8588000.0, 9865000.0, 11280000.0, 12860000.0, 14600000.0, + 16530000.0, 18670000.0, 21040000.0, 30000000.0, 35000000.0, 40000000.0}; + void GetFluidPropertiesData(EnergyPlusData &state) { @@ -534,15 +518,15 @@ namespace FluidProperties { static constexpr std::string_view routineName = "GetFluidPropertiesData"; // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - Array1D_string Alphas; // Reads string value from input file - Array1D_string cAlphaFields; // field names for alpha fields - Array1D_string cNumericFields; // field names for numeric fields - int NumAlphas; // States which alpha value to read from a "Number" line - Array1D Numbers; // brings in data from IP - Array1D_bool lAlphaFieldBlanks; // logical for blank alpha fields - Array1D_bool lNumericFieldBlanks; // logical for blank numeric fields - int NumNumbers; // States which number value to read from a "Numbers" line - int Status; // Either 1 "object found" or -1 "not found" (also used as temp) + Array1D_string Alphas; // Reads string value from input file + Array1D_string cAlphaFields; // field names for alpha fields + Array1D_string cNumericFields; // field names for numeric fields + int NumAlphas; // States which alpha value to read from a "Number" line + Array1D Numbers; // brings in data from IP + Array1D_bool lAlphaFieldBlanks; // logical for blank alpha fields + Array1D_bool lNumericFieldBlanks; // logical for blank numeric fields + int NumNumbers; // States which number value to read from a "Numbers" line + int Status; // Either 1 "object found" or -1 "not found" (also used as temp) bool ErrorsFound(false); std::string CurrentModuleObject; // for ease in renaming. @@ -558,15 +542,18 @@ namespace FluidProperties { // actual initializer into a function of one argument. auto &df = state.dataFluidProps; - + // This is here because of a unit test in HVACVRF:2358 - for (int i = 1; i <= df->refrigs.isize(); ++i) delete df->refrigs(i); + for (int i = 1; i <= df->refrigs.isize(); ++i) + delete df->refrigs(i); df->refrigs.clear(); - for (int i = 1; i <= df->glycolsRaw.isize(); ++i) delete df->glycolsRaw(i); + for (int i = 1; i <= df->glycolsRaw.isize(); ++i) + delete df->glycolsRaw(i); df->glycolsRaw.clear(); - for (int i = 1; i <= df->glycols.isize(); ++i) delete df->glycols(i); + for (int i = 1; i <= df->glycols.isize(); ++i) + delete df->glycols(i); df->glycols.clear(); - + // For default "glycol" fluids of Water, Ethylene Glycol, and Propylene Glycol // Where are these things initialized? @@ -584,7 +571,6 @@ namespace FluidProperties { // Object Data Array1D FluidTemps; - int MaxAlphas = 0; int MaxNumbers = 0; if (state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "FluidProperties:Name") > 0) { @@ -644,7 +630,7 @@ namespace FluidProperties { steam->Name = "STEAM"; df->refrigs.push_back(steam); steam->Num = df->refrigs.isize(); - + // Check to see if there is any FluidName input. If not, this is okay as // long as the user only desires to simulate loops with water. More than // one FluidName input is not allowed. @@ -737,7 +723,7 @@ namespace FluidProperties { for (int Loop = 1; Loop <= NumOfFluidTempArrays; ++Loop) { auto &tempArray = FluidTemps(Loop); - + state.dataInputProcessing->inputProcessor->getObjectItem(state, CurrentModuleObject, Loop, @@ -760,8 +746,7 @@ namespace FluidProperties { for (int TempLoop = 2; TempLoop <= tempArray.NumOfTemps; ++TempLoop) { if (tempArray.Temps(TempLoop) <= tempArray.Temps(TempLoop - 1)) { ShowSevereError( - state, - format("{}: {} name={}, lists must have data in ascending order", routineName, CurrentModuleObject, tempArray.Name)); + state, format("{}: {} name={}, lists must have data in ascending order", routineName, CurrentModuleObject, tempArray.Name)); ShowContinueError(state, format("First out of order occurrence at Temperature #({}) {{{:.R3}}} >= Temp({}) {{{:.R3}}}", TempLoop - 1, @@ -775,9 +760,9 @@ namespace FluidProperties { } // For each property, cycle through all the valid input until the proper match is found. - + // ********** SATURATED DATA SECTION ********** - + // Get: ***** Saturation Pressure temperatures and data (fluidgas only) ***** // This section added by S.J.Rees May 2002. CurrentModuleObject = "FluidProperties:Saturated"; @@ -797,7 +782,7 @@ namespace FluidProperties { cNumericFields); ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; - + auto *refrig = GetRefrig(state, Alphas(1)); if (refrig == nullptr) { ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); @@ -817,10 +802,10 @@ namespace FluidProperties { ShowSevereItemNotFound(state, eoh, cAlphaFields(4), Alphas(4)); ErrorsFound = true; continue; - } + } auto &tempArray = FluidTemps(tempArrayNum); - + // Make sure the number of points in the two arrays (temps and values) are the same if (NumNumbers != tempArray.NumOfTemps) { ShowSevereError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); @@ -828,18 +813,19 @@ namespace FluidProperties { format("Temperature Name={}, Temperature array and fluid saturation pressure array must have the " "same number of points", tempArray.Name)); - ShowContinueError(state, format("Temperature # points={} whereas {} # {} points={}", tempArray.NumOfTemps, refrig->Name, Alphas(2), NumNumbers)); + ShowContinueError( + state, format("Temperature # points={} whereas {} # {} points={}", tempArray.NumOfTemps, refrig->Name, Alphas(2), NumNumbers)); ErrorsFound = true; break; // the TempLoop DO Loop } - + if (Alphas(2) == "PRESSURE" && Alphas(3) == "FLUIDGAS") { refrig->NumPsPoints = tempArray.NumOfTemps; refrig->PsTemps.allocate(refrig->NumPsPoints); refrig->PsValues.allocate(refrig->NumPsPoints); refrig->PsTemps = tempArray.Temps; refrig->PsValues = Numbers({1, NumNumbers}); - + } else if (Alphas(2) == "ENTHALPY" && Alphas(3) == "FLUID") { refrig->NumHPoints = tempArray.NumOfTemps; refrig->HTemps.allocate(refrig->NumHPoints); @@ -859,7 +845,7 @@ namespace FluidProperties { refrig->CpTemps = tempArray.Temps; refrig->CpfValues = Numbers({1, NumNumbers}); - } else if (Alphas(2) == "SPECIFICHEAT" && Alphas(3) == "FLUIDGAS") { + } else if (Alphas(2) == "SPECIFICHEAT" && Alphas(3) == "FLUIDGAS") { refrig->NumCpPoints = tempArray.NumOfTemps; refrig->CpfgValues.allocate(refrig->NumCpPoints); refrig->CpfgValues = Numbers({1, NumNumbers}); @@ -883,7 +869,7 @@ namespace FluidProperties { ShowContinueError(state, format(R"(Valid choices are "Enthalpy", "SpecificHeat", "Density".)")); ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); } - + } else if (Alphas(3) == "FLUIDGAS") { if (Alphas(2) != "PRESSURE" && Alphas(2) != "ENTHALPY" && Alphas(2) != "SPECIFICHEAT" && Alphas(2) != "DENSITY") { ShowWarningError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); @@ -898,21 +884,22 @@ namespace FluidProperties { ShowContinueError(state, "This fluid property will not be processed nor available for the simulation."); } } // for (inData) - for (auto const *refrig : df->refrigs) { ErrorObjectHeader eoh{routineName, CurrentModuleObject, refrig->Name}; if (refrig->PsValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format(R"(No Gas/Fluid Saturation Pressure found. Need properties with {}="Pressure" and {}="FluidGas".)", cAlphaFields(2), cAlphaFields(3))); ErrorsFound = true; } - if (refrig->HfValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, + if (refrig->HfValues.size() == 0) { + ShowSevereCustomMessage(state, + eoh, format(R"(No Saturated Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="Fluid".)", cAlphaFields(2), cAlphaFields(3))); @@ -920,15 +907,17 @@ namespace FluidProperties { } if (refrig->HfgValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, - format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="FluidGas".)", - cAlphaFields(2), - cAlphaFields(3))); + ShowSevereCustomMessage(state, + eoh, + format(R"(No Saturated Gas/Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); ErrorsFound = true; } if (refrig->CpfValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format(R"(No Saturated Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="Fluid".)", cAlphaFields(2), cAlphaFields(3))); @@ -936,15 +925,18 @@ namespace FluidProperties { } if (refrig->CpfgValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, - format(R"(No Saturated Gas/Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="FluidGas".)", - cAlphaFields(2), - cAlphaFields(3))); + ShowSevereCustomMessage( + state, + eoh, + format(R"(No Saturated Gas/Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); ErrorsFound = true; } if (refrig->RhofValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format(R"(No Saturated Fluid Density found. Need properties with {}="Density" and {}="Fluid".)", cAlphaFields(2), cAlphaFields(3))); @@ -952,14 +944,14 @@ namespace FluidProperties { } if (refrig->RhofgValues.size() == 0) { - ShowSevereCustomMessage(state, eoh, - format(R"(No Saturated Gas/Fluid Density found. Need properties with {}="Density" and {}="FluidGas".)", - cAlphaFields(2), - cAlphaFields(3))); + ShowSevereCustomMessage(state, + eoh, + format(R"(No Saturated Gas/Fluid Density found. Need properties with {}="Density" and {}="FluidGas".)", + cAlphaFields(2), + cAlphaFields(3))); ErrorsFound = true; } } // for (refrigNum) - // Check: TEMPERATURES for saturated density (must all be the same) // IF (RefrigData(Loop)%NumCpPoints /= RefrigData(Loop)%NumCpPoints) THEN @@ -983,12 +975,12 @@ namespace FluidProperties { // ENDIF // END DO // END IF - + // ********** SUPERHEATED DATA SECTION ********** // Get: ***** ENTHALPY of SUPERHEATED GAS ***** // First find the number of pressure value syntax lines have been entered and // make sure that all of the pressure input is linked to the same temperature list - + // Need to do a setup pass to find the number of pressure points CurrentModuleObject = "FluidProperties:Superheated"; for (int InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { @@ -1004,16 +996,16 @@ namespace FluidProperties { lAlphaFieldBlanks, cAlphaFields, cNumericFields); - + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; - + auto *refrig = GetRefrig(state, Alphas(1)); if (refrig == nullptr) { ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); ErrorsFound = true; continue; } - + if (refrig->supTempArrayName != "" && refrig->supTempArrayName != Alphas(3)) { ShowSevereCustomMessage(state, eoh, "Saturated temperature arrays are not the same for different properties"); ErrorsFound = true; @@ -1021,10 +1013,9 @@ namespace FluidProperties { } refrig->supTempArrayName = Alphas(3); - - if (Alphas(2) != "ENTHALPY") - continue; - + + if (Alphas(2) != "ENTHALPY") continue; + int supTempArrayNum = Util::FindItemInList(refrig->supTempArrayName, FluidTemps); if (supTempArrayNum == 0) { ShowSevereItemNotFound(state, eoh, cAlphaFields(3), Alphas(3)); @@ -1036,14 +1027,14 @@ namespace FluidProperties { refrig->NumSupTempPoints = supTempArray.NumOfTemps; refrig->SupTemps.allocate(refrig->NumSupTempPoints); refrig->SupTemps = supTempArray.Temps; - + if (Numbers(1) <= 0.0) { ShowSevereError(state, format("{}: {} Name={}", routineName, CurrentModuleObject, refrig->Name)); ShowContinueError(state, format("Negative pressures not allowed in fluid property input data, Value =[{:.3R}].", Numbers(1))); ErrorsFound = true; continue; } - + if (std::find(refrig->SupPress.begin(), refrig->SupPress.end(), Numbers(1)) == refrig->SupPress.end()) { refrig->SupPress.push_back(Numbers(1)); ++refrig->NumSupPressPoints; @@ -1055,11 +1046,11 @@ namespace FluidProperties { if (refrig->Name == "STEAM") continue; std::sort(refrig->SupPress.begin(), refrig->SupPress.end()); - + refrig->HshValues.allocate(refrig->NumSupPressPoints, refrig->NumSupTempPoints); refrig->RhoshValues.allocate(refrig->NumSupPressPoints, refrig->NumSupTempPoints); } - + // Finally, get the pressure and enthalpy values from the user input CurrentModuleObject = "FluidProperties:Superheated"; for (int InData = 1; InData <= NumOfSHFluidPropArrays; ++InData) { @@ -1076,54 +1067,59 @@ namespace FluidProperties { cAlphaFields, cNumericFields); - ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; - + auto *refrig = GetRefrig(state, Alphas(1)); if (refrig == nullptr) { ShowSevereItemNotFound(state, eoh, cAlphaFields(1), Alphas(1)); ErrorsFound = true; continue; } - + if ((NumNumbers - 1) != refrig->NumSupTempPoints) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("Number of superheated {} points ({}) not equal to number of temperature points ({})", - Alphas(2), NumNumbers - 1, refrig->NumSupTempPoints)); + Alphas(2), + NumNumbers - 1, + refrig->NumSupTempPoints)); ErrorsFound = true; continue; } - + // Find which pressure point this temperature series belongs to auto pressFound = std::find(refrig->SupPress.begin(), refrig->SupPress.end(), Numbers(1)); assert(pressFound != refrig->SupPress.end()); int pressNum = (pressFound - refrig->SupPress.begin()) + 1; - if (Alphas(2) == "ENTHALPY") { + if (Alphas(2) == "ENTHALPY") { refrig->HshValues(pressNum, {1, refrig->NumSupTempPoints}) = Numbers({2, NumNumbers}); } else if (Alphas(2) == "DENSITY") { refrig->RhoshValues(pressNum, {1, refrig->NumSupTempPoints}) = Numbers({2, NumNumbers}); } else { - ShowWarningInvalidKey(state, eoh, cAlphaFields(2), Alphas(2), "", + ShowWarningInvalidKey(state, + eoh, + cAlphaFields(2), + Alphas(2), + "", format("Valid options are (\"Enthalpy\", \"Density\"). Fluid will not be available for simulation.")); ErrorsFound = true; continue; } } // for (InData) - // *************** RAW GLYCOLS *************** // Go through each glycol found in the fluid names statement and read in the data // Note that every valid fluid must have ALL of the necessary data or a fatal error will // be produced. // Propylene and ethylene are available by default - + auto *waterRaw = GetGlycolRaw(state, "WATER"); if (waterRaw == nullptr) { waterRaw = new GlycolRawProps; waterRaw->Name = "WATER"; - + df->glycolsRaw.push_back(waterRaw); waterRaw->Num = df->glycolsRaw.isize(); } @@ -1175,66 +1171,66 @@ namespace FluidProperties { df->glycolsRaw.push_back(ethylene); ethylene->Num = df->glycolsRaw.isize(); } - + // Specific Heat - ethylene->CpDataPresent = true; // Flag set when specific heat data is available - ethylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat - ethylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat + ethylene->CpDataPresent = true; // Flag set when specific heat data is available + ethylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat + ethylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat - ethylene->CpTemps.allocate(ethylene->NumCpTempPoints); // Temperatures for specific heat of glycol + ethylene->CpTemps.allocate(ethylene->NumCpTempPoints); // Temperatures for specific heat of glycol ethylene->CpTemps = DefaultGlycolTemps; - - ethylene->CpConcs.allocate(ethylene->NumCpConcPoints); // Concentration for specific heat of glycol + + ethylene->CpConcs.allocate(ethylene->NumCpConcPoints); // Concentration for specific heat of glycol ethylene->CpConcs = DefaultGlycolConcs; - ethylene->CpValues.allocate(ethylene->NumCpConcPoints, ethylene->NumCpTempPoints); // Specific heat data values + ethylene->CpValues.allocate(ethylene->NumCpConcPoints, ethylene->NumCpTempPoints); // Specific heat data values for (int i = 1; i <= ethylene->NumCpConcPoints; ++i) - ethylene->CpValues(i, {1, ethylene->NumCpTempPoints}) = DefaultEthGlyCpData[i-1]; + ethylene->CpValues(i, {1, ethylene->NumCpTempPoints}) = DefaultEthGlyCpData[i - 1]; // Density - ethylene->RhoDataPresent = true; + ethylene->RhoDataPresent = true; ethylene->NumRhoTempPoints = DefaultNumGlyTemps; ethylene->NumRhoConcPoints = DefaultNumGlyConcs; - ethylene->RhoTemps.allocate(ethylene->NumRhoTempPoints); // Temperatures for density of glycol + ethylene->RhoTemps.allocate(ethylene->NumRhoTempPoints); // Temperatures for density of glycol ethylene->RhoTemps = DefaultGlycolTemps; - ethylene->RhoConcs.allocate(ethylene->NumRhoConcPoints); // Concentration for density of glycol + ethylene->RhoConcs.allocate(ethylene->NumRhoConcPoints); // Concentration for density of glycol ethylene->RhoConcs = DefaultGlycolConcs; - - ethylene->RhoValues.allocate(ethylene->NumRhoConcPoints, ethylene->NumRhoTempPoints); // Density data values + + ethylene->RhoValues.allocate(ethylene->NumRhoConcPoints, ethylene->NumRhoTempPoints); // Density data values for (int i = 1; i <= ethylene->NumRhoConcPoints; ++i) - ethylene->RhoValues(i, {1, ethylene->NumRhoTempPoints}) = DefaultEthGlyRhoData[i-1]; + ethylene->RhoValues(i, {1, ethylene->NumRhoTempPoints}) = DefaultEthGlyRhoData[i - 1]; // Conductivity - ethylene->CondDataPresent = true; + ethylene->CondDataPresent = true; ethylene->NumCondTempPoints = DefaultNumGlyTemps; ethylene->NumCondConcPoints = DefaultNumGlyConcs; - ethylene->CondTemps.allocate(ethylene->NumCondTempPoints); // Temperatures for density of glycol + ethylene->CondTemps.allocate(ethylene->NumCondTempPoints); // Temperatures for density of glycol ethylene->CondTemps = DefaultGlycolTemps; - ethylene->CondConcs.allocate(ethylene->NumCondConcPoints); // Concentration for density of glycol + ethylene->CondConcs.allocate(ethylene->NumCondConcPoints); // Concentration for density of glycol ethylene->CondConcs = DefaultGlycolConcs; - - ethylene->CondValues.allocate(ethylene->NumCondConcPoints, ethylene->NumCondTempPoints); // Density data values + + ethylene->CondValues.allocate(ethylene->NumCondConcPoints, ethylene->NumCondTempPoints); // Density data values for (int i = 1; i <= ethylene->NumCondConcPoints; ++i) - ethylene->CondValues(i, {1, ethylene->NumCondTempPoints}) = DefaultEthGlyCondData[i-1]; + ethylene->CondValues(i, {1, ethylene->NumCondTempPoints}) = DefaultEthGlyCondData[i - 1]; // Viscosity - ethylene->ViscDataPresent = true; + ethylene->ViscDataPresent = true; ethylene->NumViscTempPoints = DefaultNumGlyTemps; ethylene->NumViscConcPoints = DefaultNumGlyConcs; - ethylene->ViscTemps.allocate(ethylene->NumViscTempPoints); // Temperatures for density of glycol + ethylene->ViscTemps.allocate(ethylene->NumViscTempPoints); // Temperatures for density of glycol ethylene->ViscTemps = DefaultGlycolTemps; - ethylene->ViscConcs.allocate(ethylene->NumViscConcPoints); // Concentration for density of glycol + ethylene->ViscConcs.allocate(ethylene->NumViscConcPoints); // Concentration for density of glycol ethylene->ViscConcs = DefaultGlycolConcs; - - ethylene->ViscValues.allocate(ethylene->NumViscConcPoints, ethylene->NumViscTempPoints); // Density data values + + ethylene->ViscValues.allocate(ethylene->NumViscConcPoints, ethylene->NumViscTempPoints); // Density data values for (int i = 1; i <= ethylene->NumViscConcPoints; ++i) - ethylene->ViscValues(i, {1, ethylene->NumViscTempPoints}) = DefaultEthGlyViscData[i-1]; + ethylene->ViscValues(i, {1, ethylene->NumViscTempPoints}) = DefaultEthGlyViscData[i - 1]; // Propylene auto *propylene = GetGlycolRaw(state, "PROPYLENEGLYCOL"); @@ -1244,69 +1240,68 @@ namespace FluidProperties { df->glycolsRaw.push_back(propylene); propylene->Num = df->glycolsRaw.isize(); } - + // Specific Heat - propylene->CpDataPresent = true; // Flag set when specific heat data is available - propylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat - propylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat + propylene->CpDataPresent = true; // Flag set when specific heat data is available + propylene->NumCpTempPoints = DefaultNumGlyTemps; // Number of temperature points for specific heat + propylene->NumCpConcPoints = DefaultNumGlyConcs; // Number of concentration points for specific heat // No ObjexxFCL templates for assigning std::array to Array1S, Probably want to covert these Array1D and 2D to std::vector eventually anyway - propylene->CpTemps.allocate(propylene->NumCpTempPoints); // Temperatures for specific heat of glycol + propylene->CpTemps.allocate(propylene->NumCpTempPoints); // Temperatures for specific heat of glycol propylene->CpTemps = DefaultGlycolTemps; - - propylene->CpConcs.allocate(propylene->NumCpConcPoints); // Concentration for specific heat of glycol + + propylene->CpConcs.allocate(propylene->NumCpConcPoints); // Concentration for specific heat of glycol propylene->CpConcs = DefaultGlycolConcs; - propylene->CpValues.allocate(propylene->NumCpConcPoints, propylene->NumCpTempPoints); // Specific heat data values + propylene->CpValues.allocate(propylene->NumCpConcPoints, propylene->NumCpTempPoints); // Specific heat data values for (int i = 1; i <= propylene->NumCpConcPoints; ++i) - propylene->CpValues(i, {1, propylene->NumCpTempPoints}) = DefaultPropGlyCpData[i-1]; + propylene->CpValues(i, {1, propylene->NumCpTempPoints}) = DefaultPropGlyCpData[i - 1]; // Density - propylene->RhoDataPresent = true; + propylene->RhoDataPresent = true; propylene->NumRhoTempPoints = DefaultNumGlyTemps; propylene->NumRhoConcPoints = DefaultNumGlyConcs; - propylene->RhoTemps.allocate(propylene->NumRhoTempPoints); // Temperatures for density of glycol + propylene->RhoTemps.allocate(propylene->NumRhoTempPoints); // Temperatures for density of glycol propylene->RhoTemps = DefaultGlycolTemps; - propylene->RhoConcs.allocate(propylene->NumRhoConcPoints); // Concentration for density of glycol + propylene->RhoConcs.allocate(propylene->NumRhoConcPoints); // Concentration for density of glycol propylene->RhoConcs = DefaultGlycolConcs; - - propylene->RhoValues.allocate(propylene->NumRhoConcPoints, propylene->NumRhoTempPoints); // Density data values + + propylene->RhoValues.allocate(propylene->NumRhoConcPoints, propylene->NumRhoTempPoints); // Density data values for (int i = 1; i <= propylene->NumRhoConcPoints; ++i) - propylene->RhoValues(i, {1, propylene->NumRhoTempPoints}) = DefaultPropGlyRhoData[i-1]; + propylene->RhoValues(i, {1, propylene->NumRhoTempPoints}) = DefaultPropGlyRhoData[i - 1]; // Conductivity - propylene->CondDataPresent = true; + propylene->CondDataPresent = true; propylene->NumCondTempPoints = DefaultNumGlyTemps; propylene->NumCondConcPoints = DefaultNumGlyConcs; - propylene->CondTemps.allocate(propylene->NumCondTempPoints); // Temperatures for density of glycol + propylene->CondTemps.allocate(propylene->NumCondTempPoints); // Temperatures for density of glycol propylene->CondTemps = DefaultGlycolTemps; - propylene->CondConcs.allocate(propylene->NumCondConcPoints); // Concentration for density of glycol + propylene->CondConcs.allocate(propylene->NumCondConcPoints); // Concentration for density of glycol propylene->CondConcs = DefaultGlycolConcs; - - propylene->CondValues.allocate(propylene->NumCondConcPoints, propylene->NumCondTempPoints); // Density data values + + propylene->CondValues.allocate(propylene->NumCondConcPoints, propylene->NumCondTempPoints); // Density data values for (int i = 1; i <= propylene->NumCondConcPoints; ++i) - propylene->CondValues(i, {1, propylene->NumCondTempPoints}) = DefaultPropGlyCondData[i-1]; + propylene->CondValues(i, {1, propylene->NumCondTempPoints}) = DefaultPropGlyCondData[i - 1]; // Viscosity - propylene->ViscDataPresent = true; + propylene->ViscDataPresent = true; propylene->NumViscTempPoints = DefaultNumGlyTemps; propylene->NumViscConcPoints = DefaultNumGlyConcs; - propylene->ViscTemps.allocate(propylene->NumViscTempPoints); // Temperatures for density of glycol + propylene->ViscTemps.allocate(propylene->NumViscTempPoints); // Temperatures for density of glycol propylene->ViscTemps = DefaultGlycolTemps; - propylene->ViscConcs.allocate(propylene->NumViscConcPoints); // Concentration for density of glycol + propylene->ViscConcs.allocate(propylene->NumViscConcPoints); // Concentration for density of glycol propylene->ViscConcs = DefaultGlycolConcs; - - propylene->ViscValues.allocate(propylene->NumViscConcPoints, propylene->NumViscTempPoints); // Density data values + + propylene->ViscValues.allocate(propylene->NumViscConcPoints, propylene->NumViscTempPoints); // Density data values for (int i = 1; i <= propylene->NumViscConcPoints; ++i) - propylene->ViscValues(i, {1, propylene->NumViscTempPoints}) = DefaultPropGlyViscData[i-1]; + propylene->ViscValues(i, {1, propylene->NumViscTempPoints}) = DefaultPropGlyViscData[i - 1]; - CurrentModuleObject = "FluidProperties:Concentration"; for (int InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { // check temperatures given for specific heat are consistant state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1323,7 +1318,7 @@ namespace FluidProperties { cNumericFields); if (Alphas(1) == "WATER") continue; // Is this the right thing to do? - + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; auto *glycolRaw = GetGlycolRaw(state, Alphas(1)); @@ -1338,19 +1333,22 @@ namespace FluidProperties { ErrorsFound = true; continue; } - + if (Numbers(1) < 0.0) { ShowSevereCustomMessage(state, eoh, "Negative concentrations not allowed in fluid property input data"); ErrorsFound = true; continue; } - + // Can temperatue and pressure points be different for different properties? Why is this allowed? if (Alphas(2) == "SPECIFICHEAT") { if (glycolRaw->CpTempArrayName != "" && glycolRaw->CpTempArrayName != Alphas(3)) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("All specific heat data for the same glycol must use the same temperature list" - "Expected name={}, Entered name={}", glycolRaw->CpTempArrayName, Alphas(3))); + "Expected name={}, Entered name={}", + glycolRaw->CpTempArrayName, + Alphas(3))); ErrorsFound = true; continue; } @@ -1364,14 +1362,17 @@ namespace FluidProperties { } else if (Alphas(2) == "DENSITY") { if (glycolRaw->RhoTempArrayName != "" && glycolRaw->RhoTempArrayName != Alphas(3)) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("All density data for the same glycol must use the same temperature list" - "Expected name={}, Entered name={}", glycolRaw->RhoTempArrayName, Alphas(3))); + "Expected name={}, Entered name={}", + glycolRaw->RhoTempArrayName, + Alphas(3))); ErrorsFound = true; continue; } glycolRaw->RhoTempArrayName = Alphas(3); - + if (std::find(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end(), Numbers(1)) == glycolRaw->RhoConcs.end()) { glycolRaw->RhoConcs.push_back(Numbers(1)); ++glycolRaw->NumRhoConcPoints; @@ -1380,14 +1381,17 @@ namespace FluidProperties { } else if (Alphas(2) == "CONDUCTIVITY") { if (glycolRaw->CondTempArrayName != "" && glycolRaw->CondTempArrayName != Alphas(3)) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("All conductivity data for the same glycol must use the same temperature list" - "Expected name={}, Entered name={}", glycolRaw->CondTempArrayName, Alphas(3))); + "Expected name={}, Entered name={}", + glycolRaw->CondTempArrayName, + Alphas(3))); ErrorsFound = true; continue; } glycolRaw->CondTempArrayName = Alphas(3); - + if (std::find(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end(), Numbers(1)) == glycolRaw->CondConcs.end()) { glycolRaw->CondConcs.push_back(Numbers(1)); ++glycolRaw->NumCondConcPoints; @@ -1396,14 +1400,17 @@ namespace FluidProperties { } else if (Alphas(2) == "VISCOSITY") { if (glycolRaw->ViscTempArrayName != "" && glycolRaw->ViscTempArrayName != Alphas(3)) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("All conductivity data for the same glycol must use the same temperature list" - "Expected name={}, Entered name={}", glycolRaw->ViscTempArrayName, Alphas(3))); + "Expected name={}, Entered name={}", + glycolRaw->ViscTempArrayName, + Alphas(3))); ErrorsFound = true; continue; } glycolRaw->ViscTempArrayName = Alphas(3); - + if (std::find(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end(), Numbers(1)) == glycolRaw->ViscConcs.end()) { glycolRaw->ViscConcs.push_back(Numbers(1)); ++glycolRaw->NumViscConcPoints; @@ -1411,8 +1418,8 @@ namespace FluidProperties { glycolRaw->ViscDataPresent = true; } else { - ShowSevereInvalidKey(state, eoh, cAlphaFields(2), Alphas(2), - "Valid options are (\"Specific Heat\", \"Density\", \"Conductivity\", \"Viscosity\")"); + ShowSevereInvalidKey( + state, eoh, cAlphaFields(2), Alphas(2), "Valid options are (\"Specific Heat\", \"Density\", \"Conductivity\", \"Viscosity\")"); ErrorsFound = true; } } @@ -1426,18 +1433,18 @@ namespace FluidProperties { glycolRaw->NumCpTempPoints = cpTempArray.NumOfTemps; glycolRaw->CpTemps.allocate(glycolRaw->NumCpTempPoints); glycolRaw->CpTemps = cpTempArray.Temps; - + glycolRaw->CpValues.allocate(glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints); std::sort(glycolRaw->CpConcs.begin(), glycolRaw->CpConcs.end()); } - + if (!glycolRaw->RhoTempArrayName.empty()) { int rhoTempArrayNum = Util::FindItemInList(glycolRaw->RhoTempArrayName, FluidTemps); auto &rhoTempArray = FluidTemps(rhoTempArrayNum); glycolRaw->NumRhoTempPoints = rhoTempArray.NumOfTemps; glycolRaw->RhoTemps.allocate(glycolRaw->NumRhoTempPoints); glycolRaw->RhoTemps = rhoTempArray.Temps; - + glycolRaw->RhoValues.allocate(glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints); std::sort(glycolRaw->RhoConcs.begin(), glycolRaw->RhoConcs.end()); } @@ -1448,7 +1455,7 @@ namespace FluidProperties { glycolRaw->NumCondTempPoints = condTempArray.NumOfTemps; glycolRaw->CondTemps.allocate(glycolRaw->NumCondTempPoints); glycolRaw->CondTemps = condTempArray.Temps; - + glycolRaw->CondValues.allocate(glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints); std::sort(glycolRaw->CondConcs.begin(), glycolRaw->CondConcs.end()); } @@ -1459,12 +1466,12 @@ namespace FluidProperties { glycolRaw->NumViscTempPoints = viscTempArray.NumOfTemps; glycolRaw->ViscTemps.allocate(glycolRaw->NumViscTempPoints); glycolRaw->ViscTemps = viscTempArray.Temps; - + glycolRaw->ViscValues.allocate(glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints); std::sort(glycolRaw->ViscConcs.begin(), glycolRaw->ViscConcs.end()); } } - + // Finally, get the specific heat and concentration values from the user input CurrentModuleObject = "FluidProperties:Concentration"; for (int InData = 1; InData <= NumOfGlyFluidPropArrays; ++InData) { @@ -1482,16 +1489,18 @@ namespace FluidProperties { cNumericFields); if (Alphas(1) == "WATER") continue; // Is this the right thing to do? - + ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)}; auto *glycolRaw = GetGlycolRaw(state, Alphas(1)); assert(glycolRaw != nullptr); // We've already tested for this, can just assert now if (Alphas(2) == "SPECIFICHEAT") { if ((NumNumbers - 1) != glycolRaw->NumCpTempPoints) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("Number of specific heat points ({}) not equal to number of temperature points ({})", - NumNumbers - 1, glycolRaw->NumCpTempPoints)); + NumNumbers - 1, + glycolRaw->NumCpTempPoints)); ErrorsFound = true; continue; } @@ -1500,11 +1509,13 @@ namespace FluidProperties { int concNum = (concFound - glycolRaw->CpConcs.begin()) + 1; glycolRaw->CpValues(concNum, {1, glycolRaw->NumCpTempPoints}) = Numbers({2, NumNumbers}); - } else if (Alphas(2) == "DENSITY") { + } else if (Alphas(2) == "DENSITY") { if ((NumNumbers - 1) != glycolRaw->NumRhoTempPoints) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("Number of density points ({}) not equal to number of temperature points ({})", - NumNumbers - 1, glycolRaw->NumRhoTempPoints)); + NumNumbers - 1, + glycolRaw->NumRhoTempPoints)); ErrorsFound = true; continue; } @@ -1513,11 +1524,13 @@ namespace FluidProperties { int concNum = (concFound - glycolRaw->RhoConcs.begin()) + 1; glycolRaw->RhoValues(concNum, {1, glycolRaw->NumRhoTempPoints}) = Numbers({2, NumNumbers}); - } else if (Alphas(2) == "CONDUCTIVITY") { + } else if (Alphas(2) == "CONDUCTIVITY") { if ((NumNumbers - 1) != glycolRaw->NumCondTempPoints) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("Number of conductivity points ({}) not equal to number of temperature points ({})", - NumNumbers - 1, glycolRaw->NumCondTempPoints)); + NumNumbers - 1, + glycolRaw->NumCondTempPoints)); ErrorsFound = true; continue; } @@ -1525,12 +1538,14 @@ namespace FluidProperties { assert(concFound != glycolRaw->CondConcs.end()); int concNum = (concFound - glycolRaw->CondConcs.begin()) + 1; glycolRaw->CondValues(concNum, {1, glycolRaw->NumCondTempPoints}) = Numbers({2, NumNumbers}); - - } else if (Alphas(2) == "VISCOSITY") { + + } else if (Alphas(2) == "VISCOSITY") { if ((NumNumbers - 1) != glycolRaw->NumViscTempPoints) { - ShowSevereCustomMessage(state, eoh, + ShowSevereCustomMessage(state, + eoh, format("Number of viscosity points ({}) not equal to number of temperature points ({})", - NumNumbers - 1, glycolRaw->NumViscTempPoints)); + NumNumbers - 1, + glycolRaw->NumViscTempPoints)); ErrorsFound = true; continue; } @@ -1578,7 +1593,7 @@ namespace FluidProperties { water->Name = "WATER"; water->GlycolName = "WATER"; water->used = true; // mark Water as always used - + df->glycols.push_back(water); water->Num = df->glycols.isize(); } @@ -1608,21 +1623,21 @@ namespace FluidProperties { water->ViscTemps = DefaultGlycolTemps; water->ViscValues = DefaultWaterViscData; -#ifdef PERFORMANCE_OPT +#ifdef PERFORMANCE_OPT // This is a speed optimization. Maybe. water->CpTempRatios.allocate(water->NumCpTempPoints); for (int i = 1; i < water->NumCpTempPoints; ++i) - water->CpTempRatios(i) = (water->CpValues(i+1) - water->CpValues(i)) / (water->CpTemps(i+1) - water->CpTemps(i)); + water->CpTempRatios(i) = (water->CpValues(i + 1) - water->CpValues(i)) / (water->CpTemps(i + 1) - water->CpTemps(i)); water->RhoTempRatios.allocate(water->NumRhoTempPoints); for (int i = 1; i < water->NumRhoTempPoints; ++i) - water->RhoTempRatios(i) = (water->RhoValues(i+1) - water->RhoValues(i)) / (water->RhoTemps(i+1) - water->RhoTemps(i)); + water->RhoTempRatios(i) = (water->RhoValues(i + 1) - water->RhoValues(i)) / (water->RhoTemps(i + 1) - water->RhoTemps(i)); water->CondTempRatios.allocate(water->NumCondTempPoints); for (int i = 1; i < water->NumCondTempPoints; ++i) - water->CondTempRatios(i) = (water->CondValues(i+1) - water->CondValues(i)) / (water->CondTemps(i+1) - water->CondTemps(i)); + water->CondTempRatios(i) = (water->CondValues(i + 1) - water->CondValues(i)) / (water->CondTemps(i + 1) - water->CondTemps(i)); water->ViscTempRatios.allocate(water->NumViscTempPoints); for (int i = 1; i < water->NumCondTempPoints; ++i) - water->ViscTempRatios(i) = (water->ViscValues(i+1) - water->ViscValues(i)) / (water->ViscTemps(i+1) - water->ViscTemps(i)); -#endif // PERFORMANCE_OPT + water->ViscTempRatios(i) = (water->ViscValues(i + 1) - water->ViscValues(i)) / (water->ViscTemps(i + 1) - water->ViscTemps(i)); +#endif // PERFORMANCE_OPT for (int Loop = 1; Loop <= NumOfOptionalInput; ++Loop) { state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -1649,7 +1664,7 @@ namespace FluidProperties { } GlycolRawProps *glycolRaw = nullptr; - + if (Alphas(2) == "ETHYLENEGLYCOL" || Alphas(2) == "PROPYLENEGLYCOL") { glycol->GlycolName = Alphas(2); glycolRaw = GetGlycolRaw(state, Alphas(2)); @@ -1680,13 +1695,18 @@ namespace FluidProperties { ErrorsFound = true; continue; } - + glycol->NumCpTempPoints = glycolRaw->NumCpTempPoints; glycol->CpTemps.allocate(glycol->NumCpTempPoints); glycol->CpTemps({1, glycol->NumCpTempPoints}) = glycolRaw->CpTemps({1, glycolRaw->NumCpTempPoints}); glycol->CpValues.allocate(glycol->NumCpTempPoints); - InterpValuesForGlycolConc(state, glycolRaw->NumCpConcPoints, glycolRaw->NumCpTempPoints, glycolRaw->CpConcs, glycolRaw->CpValues, - glycol->Concentration, glycol->CpValues); + InterpValuesForGlycolConc(state, + glycolRaw->NumCpConcPoints, + glycolRaw->NumCpTempPoints, + glycolRaw->CpConcs, + glycolRaw->CpValues, + glycol->Concentration, + glycol->CpValues); glycol->RhoDataPresent = glycolRaw->RhoDataPresent; if (!glycol->RhoDataPresent) { @@ -1697,13 +1717,18 @@ namespace FluidProperties { ErrorsFound = true; continue; } - + glycol->NumRhoTempPoints = glycolRaw->NumRhoTempPoints; glycol->RhoTemps.allocate(glycol->NumRhoTempPoints); glycol->RhoTemps({1, glycol->NumRhoTempPoints}) = glycolRaw->RhoTemps({1, glycolRaw->NumRhoTempPoints}); glycol->RhoValues.allocate(glycol->NumRhoTempPoints); - InterpValuesForGlycolConc(state, glycolRaw->NumRhoConcPoints, glycolRaw->NumRhoTempPoints, glycolRaw->RhoConcs, glycolRaw->RhoValues, - glycol->Concentration, glycol->RhoValues); + InterpValuesForGlycolConc(state, + glycolRaw->NumRhoConcPoints, + glycolRaw->NumRhoTempPoints, + glycolRaw->RhoConcs, + glycolRaw->RhoValues, + glycol->Concentration, + glycol->RhoValues); glycol->CondDataPresent = glycolRaw->CondDataPresent; if (!glycol->CondDataPresent) { @@ -1714,13 +1739,18 @@ namespace FluidProperties { ErrorsFound = true; continue; } - + glycol->NumCondTempPoints = glycolRaw->NumCondTempPoints; glycol->CondTemps.allocate(glycol->NumCondTempPoints); glycol->CondTemps({1, glycol->NumCondTempPoints}) = glycolRaw->CondTemps({1, glycolRaw->NumCondTempPoints}); glycol->CondValues.allocate(glycol->NumCondTempPoints); - InterpValuesForGlycolConc(state, glycolRaw->NumCondConcPoints, glycolRaw->NumCondTempPoints, glycolRaw->CondConcs, glycolRaw->CondValues, - glycol->Concentration, glycol->CondValues); + InterpValuesForGlycolConc(state, + glycolRaw->NumCondConcPoints, + glycolRaw->NumCondTempPoints, + glycolRaw->CondConcs, + glycolRaw->CondValues, + glycol->Concentration, + glycol->CondValues); glycol->ViscDataPresent = glycolRaw->ViscDataPresent; if (!glycol->ViscDataPresent) { @@ -1731,31 +1761,36 @@ namespace FluidProperties { ErrorsFound = true; continue; } - + glycol->NumViscTempPoints = glycolRaw->NumViscTempPoints; glycol->ViscTemps.allocate(glycol->NumViscTempPoints); glycol->ViscTemps({1, glycol->NumViscTempPoints}) = glycolRaw->ViscTemps({1, glycolRaw->NumViscTempPoints}); glycol->ViscValues.allocate(glycol->NumViscTempPoints); - InterpValuesForGlycolConc(state, glycolRaw->NumViscConcPoints, glycolRaw->NumViscTempPoints, glycolRaw->ViscConcs, glycolRaw->ViscValues, - glycol->Concentration, glycol->ViscValues); + InterpValuesForGlycolConc(state, + glycolRaw->NumViscConcPoints, + glycolRaw->NumViscTempPoints, + glycolRaw->ViscConcs, + glycolRaw->ViscValues, + glycol->Concentration, + glycol->ViscValues); -#ifdef PERFORMANCE_OPT +#ifdef PERFORMANCE_OPT // This is a speed optimization. Maybe. glycol->CpTempRatios.allocate(glycol->NumCpTempPoints); for (int i = 1; i < glycol->NumCpTempPoints; ++i) - glycol->CpTempRatios(i) = (glycol->CpValues(i+1) - glycol->CpValues(i)) / (glycol->CpTemps(i+1) - glycol->CpTemps(i)); + glycol->CpTempRatios(i) = (glycol->CpValues(i + 1) - glycol->CpValues(i)) / (glycol->CpTemps(i + 1) - glycol->CpTemps(i)); glycol->RhoTempRatios.allocate(glycol->NumRhoTempPoints); for (int i = 1; i < glycol->NumRhoTempPoints; ++i) - glycol->RhoTempRatios(i) = (glycol->RhoValues(i+1) - glycol->RhoValues(i)) / (glycol->RhoTemps(i+1) - glycol->RhoTemps(i)); + glycol->RhoTempRatios(i) = (glycol->RhoValues(i + 1) - glycol->RhoValues(i)) / (glycol->RhoTemps(i + 1) - glycol->RhoTemps(i)); glycol->CondTempRatios.allocate(glycol->NumCondTempPoints); for (int i = 1; i < glycol->NumCondTempPoints; ++i) - glycol->CondTempRatios(i) = (glycol->CondValues(i+1) - glycol->CondValues(i)) / (glycol->CondTemps(i+1) - glycol->CondTemps(i)); + glycol->CondTempRatios(i) = (glycol->CondValues(i + 1) - glycol->CondValues(i)) / (glycol->CondTemps(i + 1) - glycol->CondTemps(i)); glycol->ViscTempRatios.allocate(glycol->NumViscTempPoints); for (int i = 1; i < glycol->NumCondTempPoints; ++i) - glycol->ViscTempRatios(i) = (glycol->ViscValues(i+1) - glycol->ViscValues(i)) / (glycol->ViscTemps(i+1) - glycol->ViscTemps(i)); -#endif // PERFORMANCE_OPT + glycol->ViscTempRatios(i) = (glycol->ViscValues(i + 1) - glycol->ViscValues(i)) / (glycol->ViscTemps(i + 1) - glycol->ViscTemps(i)); +#endif // PERFORMANCE_OPT } // for (Loop) - + if (!ErrorsFound) InitializeGlycolTempLimits(state, ErrorsFound); // Initialize the Temp limits for the glycols if (!ErrorsFound) InitializeRefrigerantLimits(state, ErrorsFound); // Initialize the limits for the refrigerants @@ -1774,12 +1809,9 @@ namespace FluidProperties { } if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTGLYCOLS") > 0) df->DebugReportGlycols = true; - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTREFRIGERANTS") > 0) - df->DebugReportRefrigerants = true; - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEGLYCOLERRORLIMIT") > 0) - df->GlycolErrorLimitTest += 10; - if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEREFRIGERANTERRORLIMIT") > 0) - df->RefrigErrorLimitTest += 10; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("REPORTREFRIGERANTS") > 0) df->DebugReportRefrigerants = true; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEGLYCOLERRORLIMIT") > 0) df->GlycolErrorLimitTest += 10; + if (state.dataInputProcessing->inputProcessor->getNumSectionsFound("INCREASEREFRIGERANTERRORLIMIT") > 0) df->RefrigErrorLimitTest += 10; if (df->DebugReportGlycols) ReportAndTestGlycols(state); if (df->DebugReportRefrigerants) ReportAndTestRefrigerants(state); @@ -1872,7 +1904,8 @@ namespace FluidProperties { } } } else { // user has input data for concentrations that are too close or repeated, this must be fixed - ShowFatalError(state, format("{}: concentration values too close or data repeated, check your fluid property input data", routineName)); + ShowFatalError(state, + format("{}: concentration values too close or data repeated, check your fluid property input data", routineName)); } } } @@ -1892,7 +1925,7 @@ namespace FluidProperties { // be set up for symmetry and not be limited to just valid values. auto &df = state.dataFluidProps; - + for (auto *glycol : df->glycols) { if (glycol->CpDataPresent) { // check for lowest non-zero value by referencing temp data @@ -1973,8 +2006,8 @@ namespace FluidProperties { Failure = glycol->ViscLowTempIndex == 0 || glycol->ViscHighTempIndex == 0; } if (Failure) { - ShowSevereError(state, - format("InitializeGlycolTempLimits: Required values for Glycol={} are all zeroes for some data types.", glycol->Name)); + ShowSevereError( + state, format("InitializeGlycolTempLimits: Required values for Glycol={} are all zeroes for some data types.", glycol->Name)); ErrorsFound = true; } } @@ -2091,15 +2124,16 @@ namespace FluidProperties { Failure = refrig->PsLowPresIndex == 0 || refrig->PsLowTempIndex == 0 || refrig->PsHighPresIndex == 0 || refrig->PsHighTempIndex == 0; } if (refrig->NumHPoints > 0) { - Failure = refrig->HfLowTempIndex == 0 || refrig->HfgLowTempIndex == 0 || refrig->HfHighTempIndex == 0 || refrig->HfgHighTempIndex == 0; + Failure = + refrig->HfLowTempIndex == 0 || refrig->HfgLowTempIndex == 0 || refrig->HfHighTempIndex == 0 || refrig->HfgHighTempIndex == 0; } if (refrig->NumCpPoints > 0) { Failure = refrig->CpfLowTempIndex == 0 || refrig->CpfgLowTempIndex == 0 || refrig->CpfHighTempIndex == 0 || refrig->CpfgHighTempIndex == 0; } if (refrig->NumRhoPoints > 0) { - Failure = - refrig->RhofLowTempIndex == 0 || refrig->RhofgLowTempIndex == 0 || refrig->RhofHighTempIndex == 0 || refrig->RhofgHighTempIndex == 0; + Failure = refrig->RhofLowTempIndex == 0 || refrig->RhofgLowTempIndex == 0 || refrig->RhofHighTempIndex == 0 || + refrig->RhofgHighTempIndex == 0; } if (Failure) { ShowSevereError( @@ -2378,7 +2412,7 @@ namespace FluidProperties { Real64 ReturnValue; // Values returned from refrigerant functions auto &df = state.dataFluidProps; - + for (auto *refrig : df->refrigs) { // Lay out the basic values: if (!refrig->Name.empty()) { @@ -2507,7 +2541,8 @@ namespace FluidProperties { } if (refrig->NumSupTempPoints > 0 && refrig->NumSupPressPoints > 0) { - print(state.files.debug, "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", + print(state.files.debug, + "Superheated Gas Fluid Data points:,NumTemperaturePoints=,{},NumPressurePoints=,{}\n", refrig->NumSupTempPoints, refrig->NumSupPressPoints); print(state.files.debug, "Superheated Temperatures:"); @@ -2688,8 +2723,8 @@ namespace FluidProperties { //***************************************************************************** Real64 RefrigProps::getSatPressure(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -2713,7 +2748,7 @@ namespace FluidProperties { int LoTempIndex = FindArrayIndex(Temperature, this->PsTemps, this->PsLowTempIndex, this->PsHighTempIndex); auto &df = state.dataFluidProps; - + // check for out of data bounds problems if (LoTempIndex == 0) { ReturnValue = this->PsValues(this->PsLowTempIndex); @@ -2723,20 +2758,18 @@ namespace FluidProperties { ErrorFlag = true; } else { // find interpolation ratio w.r.t temperature - Real64 TempInterpRatio = (Temperature - this->PsTemps(LoTempIndex)) / (this->PsTemps(LoTempIndex+1) - this->PsTemps(LoTempIndex)); + Real64 TempInterpRatio = (Temperature - this->PsTemps(LoTempIndex)) / (this->PsTemps(LoTempIndex + 1) - this->PsTemps(LoTempIndex)); // apply final linear interpolation - ReturnValue = this->PsValues(LoTempIndex) + TempInterpRatio * (this->PsValues(LoTempIndex+1) - this->PsValues(LoTempIndex)); + ReturnValue = this->PsValues(LoTempIndex) + TempInterpRatio * (this->PsValues(LoTempIndex + 1) - this->PsValues(LoTempIndex)); } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { ++this->errors[(int)RefrigError::SatTemp].count; // send warning if (this->errors[(int)RefrigError::SatTemp].count <= df->RefrigErrorLimitTest) { - ShowSevereMessage(state, - format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", - routineName, - this->Name)); + ShowSevereMessage( + state, format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -2746,12 +2779,12 @@ namespace FluidProperties { state, format("...Supplied Refrigerant Temperature={:.2R} Returned saturated pressure value = {:.0R}", Temperature, ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringSevereErrorAtEnd(state, - format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", - routineName, this->Name), - this->errors[(int)RefrigError::SatTemp].index, - Temperature, - "{C}"); + ShowRecurringSevereErrorAtEnd( + state, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), + this->errors[(int)RefrigError::SatTemp].index, + Temperature, + "{C}"); } return ReturnValue; @@ -2759,9 +2792,9 @@ namespace FluidProperties { Real64 GetSatPressureRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSatPressure() @@ -2781,8 +2814,8 @@ namespace FluidProperties { //***************************************************************************** Real64 RefrigProps::getSatTemperature(EnergyPlusData &state, - Real64 const Pressure, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Pressure, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -2815,15 +2848,15 @@ namespace FluidProperties { if (LoPresIndex == 0) { ReturnValue = this->PsTemps(this->PsLowPresIndex); ErrorFlag = true; - } else if (LoPresIndex+1 > this->PsHighPresIndex) { + } else if (LoPresIndex + 1 > this->PsHighPresIndex) { ReturnValue = this->PsTemps(this->PsHighPresIndex); ErrorFlag = true; } else { // find interpolation ratio w.r.t temperature - Real64 PresInterpRatio = (Pressure - this->PsValues(LoPresIndex)) / (this->PsValues(LoPresIndex+1) - this->PsValues(LoPresIndex)); + Real64 PresInterpRatio = (Pressure - this->PsValues(LoPresIndex)) / (this->PsValues(LoPresIndex + 1) - this->PsValues(LoPresIndex)); // apply final linear interpolation - ReturnValue = this->PsTemps(LoPresIndex) + PresInterpRatio * (this->PsTemps(LoPresIndex+1) - this->PsTemps(LoPresIndex)); + ReturnValue = this->PsTemps(LoPresIndex) + PresInterpRatio * (this->PsTemps(LoPresIndex + 1) - this->PsTemps(LoPresIndex)); } if (!state.dataGlobal->WarmupFlag && ErrorFlag) { @@ -2831,9 +2864,7 @@ namespace FluidProperties { // send warning if (this->errors[(int)RefrigError::SatPress].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, - format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", - routineName, - this->Name)); + format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.0R},{:.0R}]", CalledFrom, @@ -2843,20 +2874,21 @@ namespace FluidProperties { state, format("...Supplied Refrigerant Pressure={:.0R} Returned saturated temperature value ={:.2R}", Pressure, ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringSevereErrorAtEnd(state, - format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), - this->errors[(int)RefrigError::SatPress].index, - Pressure, - "{Pa}"); + ShowRecurringSevereErrorAtEnd( + state, + format("{}: Saturation pressure is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), + this->errors[(int)RefrigError::SatPress].index, + Pressure, + "{Pa}"); } return ReturnValue; } Real64 GetSatTemperatureRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Pressure, // actual temperature given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Pressure, // actual temperature given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSatTemperature() @@ -2872,13 +2904,13 @@ namespace FluidProperties { return df->refrigs(RefrigIndex)->getSatTemperature(state, Pressure, CalledFrom); } - + //***************************************************************************** Real64 RefrigProps::getSatEnthalpy(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -2903,15 +2935,15 @@ namespace FluidProperties { Real64 GetSatEnthalpyRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSatEnthalpy() auto &df = state.dataFluidProps; - + if (RefrigIndex == 0) { if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); @@ -2921,13 +2953,13 @@ namespace FluidProperties { } return df->refrigs(RefrigIndex)->getSatEnthalpy(state, Temperature, Quality, CalledFrom); } - + //***************************************************************************** Real64 RefrigProps::getSatDensity(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -3003,10 +3035,8 @@ namespace FluidProperties { ++this->errors[(int)RefrigError::SatTempDensity].count; // send warning if (this->errors[(int)RefrigError::SatTempDensity].count <= df->RefrigErrorLimitTest) { - ShowSevereMessage(state, - format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", - routineName, - this->Name)); + ShowSevereMessage( + state, format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name)); ShowContinueError(state, format("...Called From:{}, supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -3016,44 +3046,45 @@ namespace FluidProperties { state, format("...Supplied Refrigerant Temperature={:.2R} Returned saturated density value ={:.2R}", Temperature, ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringSevereErrorAtEnd(state, - format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), - this->errors[(int)RefrigError::SatTempDensity].index, - Temperature, - "{C}"); + ShowRecurringSevereErrorAtEnd( + state, + format("{}: Saturation temperature is out of range for refrigerant [{}] supplied data: **", routineName, this->Name), + this->errors[(int)RefrigError::SatTempDensity].index, + Temperature, + "{C}"); } return ReturnValue; } Real64 GetSatDensityRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSatDensity() auto &df = state.dataFluidProps; - + if (RefrigIndex == 0) { - if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { + if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); ShowFatalError(state, "Program terminates due to preceding condition."); return 0.0; } } - + return df->refrigs(RefrigIndex)->getSatDensity(state, Temperature, Quality, CalledFrom); } - + //***************************************************************************** Real64 RefrigProps::getSatSpecificHeat(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - std::string_view const CalledFrom // routine this function was called from (error messages) - ) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + std::string_view const CalledFrom // routine this function was called from (error messages) + ) { // SUBROUTINE INFORMATION: @@ -3080,30 +3111,22 @@ namespace FluidProperties { } // Apply linear interpolation function - return GetInterpolatedSatProp(state, - Temperature, - this->CpTemps, - this->CpfValues, - this->CpfgValues, - Quality, - CalledFrom, - this->CpfLowTempIndex, - this->CpfHighTempIndex); - + return GetInterpolatedSatProp( + state, Temperature, this->CpTemps, this->CpfValues, this->CpfgValues, Quality, CalledFrom, this->CpfLowTempIndex, this->CpfHighTempIndex); } - + Real64 GetSatSpecificHeatRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Quality, // actual quality given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Quality, // actual quality given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSpecificHeat() auto &df = state.dataFluidProps; - + if (RefrigIndex == 0) { if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); @@ -3118,9 +3141,9 @@ namespace FluidProperties { //***************************************************************************** Real64 RefrigProps::getSupHeatEnthalpy(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -3153,10 +3176,10 @@ namespace FluidProperties { static constexpr std::string_view routineName = "RefrigProps::getSupHeatEnthalpy"; auto &df = state.dataFluidProps; - + Real64 TempInterpRatio; Real64 PressInterpRatio; - + int HiTempIndex; // high temperature index value int HiPressIndex; // high pressure index value @@ -3274,34 +3297,35 @@ namespace FluidProperties { if (this->errors[(int)RefrigError::SatSupEnthalpyTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated enthalpy: values capped **", - routineName, this->Name)); + routineName, + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated enthalpy: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, - Temperature, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated enthalpy: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyTemp].index, + Temperature, + "{C}"); } // send pressure range error if flagged this->errors[(int)RefrigError::SatSupEnthalpyPress].count += CurPresRangeErrCount; if (CurPresRangeErrCount > 0) { if (this->errors[(int)RefrigError::SatSupEnthalpyPress].count <= df->RefrigErrorLimitTest) { - ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", - routineName, this->Name)); + ShowWarningMessage( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupEnthalpyPress].index, - Pressure, - "{Pa}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupEnthalpyPress].index, + Pressure, + "{Pa}"); } } // end error checking @@ -3310,15 +3334,15 @@ namespace FluidProperties { Real64 GetSupHeatEnthalpyRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSupHeatEnthalpy() auto &df = state.dataFluidProps; - + if (RefrigIndex == 0) { if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); @@ -3329,13 +3353,13 @@ namespace FluidProperties { return df->refrigs(RefrigIndex)->getSupHeatEnthalpy(state, Temperature, Pressure, CalledFrom); } - + //***************************************************************************** Real64 RefrigProps::getSupHeatPressure(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Enthalpy, // actual enthalpy given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Enthalpy, // actual enthalpy given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -3366,10 +3390,10 @@ namespace FluidProperties { // FUNCTION PARAMETERS: // the enthalpy calculated from the pressure found static constexpr std::string_view routineName = "RefrigProps::getSupHeatPressure"; - + auto &df = state.dataFluidProps; - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: + + // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 EnthalpyCheck; // recalculates enthalpy based on calculated pressure Real64 EnthalpyHigh; // Enthalpy value at interpolated pressure and high temperature Real64 EnthalpyLow; // Enthalpy value at interpolated pressure and low temperature @@ -3513,18 +3537,21 @@ namespace FluidProperties { if (this->errors[(int)RefrigError::SatSupPress].count <= df->RefrigErrorLimitTest) { ShowSevereMessage(state, format("{}: Refrigerant [{}] is saturated at the given enthalpy and temperature, saturated enthalpy at given " - "temperature returned. **", routineName, this->Name)); + "temperature returned. **", + routineName, + this->Name)); ShowContinueError(state, fmt::format("...Called From:{}", CalledFrom)); ShowContinueError(state, format("Refrigerant temperature = {:.2R}", Temperature)); ShowContinueError(state, format("Refrigerant Enthalpy = {:.3R}", Enthalpy)); ShowContinueError(state, format("Returned Pressure value = {:.0R}", ReturnValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringSevereErrorAtEnd(state, - format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), - this->errors[(int)RefrigError::SatSupPress].index, - ReturnValue, - "{Pa}"); + ShowRecurringSevereErrorAtEnd( + state, + format("{}: Refrigerant [{}] saturated at the given enthalpy and temperature **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPress].index, + ReturnValue, + "{Pa}"); } // send temp range error if flagged @@ -3533,43 +3560,43 @@ namespace FluidProperties { if (this->errors[(int)RefrigError::SatSupPressTemp].count <= df->RefrigErrorLimitTest) { ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated pressure: values capped **", - routineName, this->Name)); + routineName, + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated pressure: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupPressTemp].index, - Temperature, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated pressure: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressTemp].index, + Temperature, + "{C}"); } // send enthalpy range error if flagged this->errors[(int)RefrigError::SatSupPressEnthalpy].count += CurEnthalpyRangeErrCount; if (CurEnthalpyRangeErrCount > 0) { if (this->errors[(int)RefrigError::SatSupPressEnthalpy].count <= df->RefrigErrorLimitTest) { - ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", - routineName, this->Name)); + ShowWarningMessage( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated enthalpy: values capped **", routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated pressure: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupPressEnthalpy].index, - Enthalpy, - "{J}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated pressure: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupPressEnthalpy].index, + Enthalpy, + "{J}"); } } // end error checking return ReturnValue; } - Real64 GetSupHeatPressureRefrig(EnergyPlusData &state, - std::string const &refrigName, // carries in substance name + std::string const &refrigName, // carries in substance name Real64 const Temperature, // actual temperature given as input Real64 const Enthalpy, // actual enthalpy given as input int &RefrigIndex, // Index to Refrigerant Properties @@ -3593,12 +3620,12 @@ namespace FluidProperties { //***************************************************************************** Real64 RefrigProps::getSupHeatTemp(EnergyPlusData &state, - Real64 const Pressure, // actual pressure given as input - Real64 const Enthalpy, // actual enthalpy given as input - Real64 TempLow, // lower bound of temperature in the iteration - Real64 TempUp, // upper bound of temperature in the iteration - std::string_view const CalledFrom // routine this function was called from (error messages) - ) + Real64 const Pressure, // actual pressure given as input + Real64 const Enthalpy, // actual enthalpy given as input + Real64 TempLow, // lower bound of temperature in the iteration + Real64 TempUp, // upper bound of temperature in the iteration + std::string_view const CalledFrom // routine this function was called from (error messages) + ) { // SUBROUTINE INFORMATION: // AUTHOR Rongpeng Zhang @@ -3693,17 +3720,17 @@ namespace FluidProperties { Real64 GetSupHeatTempRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Pressure, // actual pressure given as input - Real64 const Enthalpy, // actual enthalpy given as input - Real64 TempLow, // lower bound of temperature in the iteration - Real64 TempUp, // upper bound of temperature in the iteration - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Pressure, // actual pressure given as input + Real64 const Enthalpy, // actual enthalpy given as input + Real64 TempLow, // lower bound of temperature in the iteration + Real64 TempUp, // upper bound of temperature in the iteration + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSupHeatTemp() auto &df = state.dataFluidProps; - + if (RefrigIndex == 0) { if ((RefrigIndex = GetRefrigNum(state, refrigName)) == 0) { ShowSevereError(state, format("Refrigerant \"{}\" not found, called from: {}", refrigName, CalledFrom)); @@ -3714,13 +3741,13 @@ namespace FluidProperties { return df->refrigs(RefrigIndex)->getSupHeatTemp(state, Pressure, Enthalpy, TempLow, TempUp, CalledFrom); } - + //***************************************************************************** Real64 RefrigProps::getSupHeatDensity(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -3750,7 +3777,7 @@ namespace FluidProperties { Real64 ReturnValue; auto &df = state.dataFluidProps; - + // FUNCTION PARAMETERS: static constexpr std::string_view routineName = "RefrigProps::getSupHeatDensity"; @@ -3876,36 +3903,37 @@ namespace FluidProperties { this->errors[(int)RefrigError::SatSupDensityTemp].count += CurTempRangeErrCount; if (CurTempRangeErrCount > 0) { if (this->errors[(int)RefrigError::SatSupDensityTemp].count <= df->RefrigErrorLimitTest) { - ShowWarningMessage(state, format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", - routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", + routineName, + this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupDensityTemp].index, - Temperature, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Temperature is out of range for superheated density: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityTemp].index, + Temperature, + "{C}"); } // send pressure range error if flagged this->errors[(int)RefrigError::SatSupDensityPress].count += CurPresRangeErrCount; if (CurPresRangeErrCount > 0) { if (this->errors[(int)RefrigError::SatSupDensityPress].count <= df->RefrigErrorLimitTest) { - ShowWarningMessage(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", - routineName, - this->Name)); + ShowWarningMessage( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", routineName, this->Name)); ShowContinueError(state, fmt::format(" Called From:{}", CalledFrom)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", - routineName, this->Name), - this->errors[(int)RefrigError::SatSupDensityPress].index, - Pressure, - "{Pa}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Refrigerant [{}] Pressure is out of range for superheated density: values capped **", routineName, this->Name), + this->errors[(int)RefrigError::SatSupDensityPress].index, + Pressure, + "{Pa}"); } // end error checking } @@ -3914,10 +3942,10 @@ namespace FluidProperties { Real64 GetSupHeatDensityRefrig(EnergyPlusData &state, std::string_view const refrigName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - Real64 const Pressure, // actual pressure given as input - int &RefrigIndex, // Index to Refrigerant Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + Real64 const Pressure, // actual pressure given as input + int &RefrigIndex, // Index to Refrigerant Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for RefrigProps::getSupHeatDensity() @@ -3932,12 +3960,12 @@ namespace FluidProperties { return df->refrigs(RefrigIndex)->getSupHeatDensity(state, Temperature, Pressure, CalledFrom); } - + //***************************************************************************** #ifdef EP_cache_GlycolSpecificHeat Real64 GlycolProps::getSpecificHeat(EnergyPlusData &state, - Real64 const Temperature, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temperature, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { auto &df = state.dataFluidProps; @@ -3964,13 +3992,13 @@ namespace FluidProperties { } Real64 GlycolProps::getSpecificHeat_raw(EnergyPlusData &state, - Real64 const Temp, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temp, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) #else Real64 GlycolProps::getSpecificHeat(EnergyPlusData &state, - Real64 const Temp, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temp, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) #endif { @@ -4003,14 +4031,13 @@ namespace FluidProperties { // Now determine the value of specific heat using interpolation if (Temp < this->CpLowTempValue) { // Temperature too low - + if (!state.dataGlobal->WarmupFlag) { df->glycolErrorLimits[(int)GlycolError::SpecHeatLow] = ++this->errors[(int)GlycolError::SpecHeatLow].count; if (df->glycolErrorLimits[(int)GlycolError::SpecHeatLow] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, - format("{}: Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", - routineName, - this->Name)); + ShowWarningMessage( + state, + format("{}: Temperature is out of range (too low) for fluid [{}] specific heat supplied values **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4019,11 +4046,12 @@ namespace FluidProperties { this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), - this->errors[(int)GlycolError::SpecHeatLow].index, - Temp, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Temperature out of range (too low) for fluid [{}] specific heat **", routineName, this->Name), + this->errors[(int)GlycolError::SpecHeatLow].index, + Temp, + "{C}"); } return this->CpValues(this->CpLowTempIndex); @@ -4031,8 +4059,8 @@ namespace FluidProperties { if (!state.dataGlobal->WarmupFlag) { df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] = ++this->errors[(int)GlycolError::SpecHeatHigh].count; if (df->glycolErrorLimits[(int)GlycolError::SpecHeatHigh] <= df->GlycolErrorLimitTest) { - ShowWarningMessage( - state, format("{}: Temperature is out of range (too high) for fluid [{}] specific heat **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too high) for fluid [{}] specific heat **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4041,43 +4069,44 @@ namespace FluidProperties { this->CpHighTempValue)); ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), - this->errors[(int)GlycolError::SpecHeatHigh].index, - Temp, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Temperature out of range (too high) for fluid [{}] specific heat **", routineName, this->Name), + this->errors[(int)GlycolError::SpecHeatHigh].index, + Temp, + "{C}"); } return this->CpValues(this->CpHighTempIndex); } else { // Temperature somewhere between the lowest and highest value #ifdef PERFORMANCE_OPT - if (Temp < this->CpTemps(this->LoCpTempIdxLast) || Temp > this->CpTemps(this->LoCpTempIdxLast+1)) { + if (Temp < this->CpTemps(this->LoCpTempIdxLast) || Temp > this->CpTemps(this->LoCpTempIdxLast + 1)) { this->LoCpTempIdxLast = FindArrayIndex(Temp, this->CpTemps, 1, this->NumCpTempPoints); } return this->CpValues(this->LoCpTempIdxLast) + (Temp - this->CpTemps(this->LoCpTempIdxLast)) * this->CpTempRatios(this->LoCpTempIdxLast); -#else // !PERFORMANCE_OPT - assert(this->CpTemps.size() <= static_cast(std::numeric_limits::max())); - int beg(1), end(this->CpTemps.isize()); // 1-based indexing +#else // !PERFORMANCE_OPT + assert(this->CpTemps.size() <= static_cast(std::numeric_limits::max())); + int beg(1), end(this->CpTemps.isize()); // 1-based indexing assert(end > 0); while (beg + 1 < end) { int mid = ((beg + end) >> 1); // bit shifting is faster than /2 (Temp > this->CpTemps(mid) ? beg : end) = mid; } // Invariant: glycol_CpTemps[beg] <= Temperature <= glycol_CpTemps[end] return GetInterpValue(Temp, this->CpTemps(beg), this->CpTemps(end), this->CpValues(beg), this->CpValues(end)); -#endif // PERFORMANCE_OPT +#endif // PERFORMANCE_OPT } } Real64 GetSpecificHeatGlycol(EnergyPlusData &state, - std::string_view const glycolName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + std::string_view const glycolName, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for GlycolProps::getSpecificHeat() auto &df = state.dataFluidProps; - + if (GlycolIndex == 0) { if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); @@ -4088,12 +4117,12 @@ namespace FluidProperties { return df->glycols(GlycolIndex)->getSpecificHeat(state, Temperature, CalledFrom); } - + //***************************************************************************** Real64 GlycolProps::getDensity(EnergyPlusData &state, - Real64 const Temp, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temp, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4122,7 +4151,7 @@ namespace FluidProperties { static constexpr std::string_view routineName = "GlycolProps::getDensity"; auto &df = state.dataFluidProps; - + // FUNCTION LOCAL VARIABLE DECLARATIONS: GlycolError error = GlycolError::Invalid; @@ -4131,22 +4160,23 @@ namespace FluidProperties { // Now determine the value of specific heat using interpolation if (Temp < this->RhoLowTempValue) { // Temperature too low - error = GlycolError::DensityLow; + error = GlycolError::DensityLow; Rho = this->RhoValues(this->RhoLowTempIndex); } else if (Temp > this->RhoHighTempValue) { // Temperature too high error = GlycolError::DensityHigh; Rho = this->RhoValues(this->RhoHighTempIndex); } else { // Temperature somewhere between the lowest and highest value #ifdef PERFORMANCE_OPT - if (Temp < this->RhoTemps(this->LoRhoTempIdxLast) || Temp > this->RhoTemps(this->LoRhoTempIdxLast+1)) { + if (Temp < this->RhoTemps(this->LoRhoTempIdxLast) || Temp > this->RhoTemps(this->LoRhoTempIdxLast + 1)) { this->LoRhoTempIdxLast = FindArrayIndex(Temp, this->RhoTemps, 1, this->NumRhoTempPoints); } - Rho = this->RhoValues(this->LoRhoTempIdxLast) + (Temp - this->RhoTemps(this->LoRhoTempIdxLast)) * this->RhoTempRatios(this->LoRhoTempIdxLast); -#else // !PERFORMANCE_OPT + Rho = this->RhoValues(this->LoRhoTempIdxLast) + + (Temp - this->RhoTemps(this->LoRhoTempIdxLast)) * this->RhoTempRatios(this->LoRhoTempIdxLast); +#else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temp, this->RhoTemps, 1, this->NumRhoTempPoints); - Real64 TempInterpRatio = (Temp - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex+1) - this->RhoTemps(LoTempIndex)); - Rho = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex+1) - this->RhoValues(LoTempIndex)); -#endif // PERFORMANCE_OPT + Real64 TempInterpRatio = (Temp - this->RhoTemps(LoTempIndex)) / (this->RhoTemps(LoTempIndex + 1) - this->RhoTemps(LoTempIndex)); + Rho = this->RhoValues(LoTempIndex) + TempInterpRatio * (this->RhoValues(LoTempIndex + 1) - this->RhoValues(LoTempIndex)); +#endif // PERFORMANCE_OPT } // Error handling @@ -4170,10 +4200,11 @@ namespace FluidProperties { this->errors[(int)GlycolError::DensityLow].index, Temp, "{C}"); - + } else { // error == GlycolError::DensityHigh if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] density **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too high) for fluid [{}] density **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4194,15 +4225,15 @@ namespace FluidProperties { } Real64 GetDensityGlycol(EnergyPlusData &state, - std::string_view const glycolName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + std::string_view const glycolName, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for GlycolProps::getDensity() auto &df = state.dataFluidProps; - + if (GlycolIndex == 0) { if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); @@ -4213,12 +4244,12 @@ namespace FluidProperties { return df->glycols(GlycolIndex)->getDensity(state, Temperature, CalledFrom); } - + //***************************************************************************** Real64 GlycolProps::getConductivity(EnergyPlusData &state, - Real64 const Temp, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temp, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4250,7 +4281,7 @@ namespace FluidProperties { GlycolError error = GlycolError::Invalid; auto &df = state.dataFluidProps; - + // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value if (!this->CondDataPresent) { ShowSevereError(state, format("{}: conductivity data not found for glycol \"{}\", called from {}", routineName, this->Name, CalledFrom)); @@ -4267,14 +4298,15 @@ namespace FluidProperties { Cond = this->CondValues(this->CondHighTempIndex); } else { // Temperature somewhere between the lowest and highest value #ifdef PERFORMANCE_OPT - if (Temp < this->CondTemps(this->LoCondTempIdxLast) || Temp > this->CondTemps(this->LoCondTempIdxLast+1)) { + if (Temp < this->CondTemps(this->LoCondTempIdxLast) || Temp > this->CondTemps(this->LoCondTempIdxLast + 1)) { this->LoCondTempIdxLast = FindArrayIndex(Temp, this->CondTemps, 1, this->NumCondTempPoints); } - Cond = this->CondValues(this->LoCondTempIdxLast) + (Temp - this->CondTemps(this->LoCondTempIdxLast)) * this->CondTempRatios(this->LoCondTempIdxLast); -#else // !PERFORMANCE_OPT + Cond = this->CondValues(this->LoCondTempIdxLast) + + (Temp - this->CondTemps(this->LoCondTempIdxLast)) * this->CondTempRatios(this->LoCondTempIdxLast); +#else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temp, this->CondTemps, 1, this->NumCondTempPoints); - Real64 TempInterpRatio = (Temp - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex+1) - this->CondTemps(LoTempIndex)); - Cond = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex+1) - this->CondValues(LoTempIndex)); + Real64 TempInterpRatio = (Temp - this->CondTemps(LoTempIndex)) / (this->CondTemps(LoTempIndex + 1) - this->CondTemps(LoTempIndex)); + Cond = this->CondValues(LoTempIndex) + TempInterpRatio * (this->CondValues(LoTempIndex + 1) - this->CondValues(LoTempIndex)); #endif // PERFORMANCE_OPT } @@ -4284,7 +4316,8 @@ namespace FluidProperties { if (error == GlycolError::ConductivityLow) { if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] conductivity **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too low) for fluid [{}] conductivity **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4294,16 +4327,18 @@ namespace FluidProperties { ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), - this->errors[(int)error].index, - Temp, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Temperature out of range (too low) for fluid [{}] conductivity **", routineName, this->Name), + this->errors[(int)error].index, + Temp, + "{C}"); } else if (error == GlycolError::ConductivityHigh) { if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] conductivity **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too high) for fluid [{}] conductivity **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4313,11 +4348,12 @@ namespace FluidProperties { ShowContinueErrorTimeStamp(state, ""); } - ShowRecurringWarningErrorAtEnd(state, - format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), - this->errors[(int)error].index, - Temp, - "{C}"); + ShowRecurringWarningErrorAtEnd( + state, + format("{}: Temperature out of range (too high) for fluid [{}] conductivity **", routineName, this->Name), + this->errors[(int)error].index, + Temp, + "{C}"); } } @@ -4325,15 +4361,15 @@ namespace FluidProperties { } // GlycolProps::getConductivity() Real64 GetConductivityGlycol(EnergyPlusData &state, - std::string_view const glycolName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + std::string_view const glycolName, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for GlycolProps::getConductivity() auto &df = state.dataFluidProps; - + if (GlycolIndex == 0) { if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); @@ -4345,12 +4381,12 @@ namespace FluidProperties { // If user didn't input data (shouldn't get this far, but just in case...), we can't find a value return df->glycols(GlycolIndex)->getConductivity(state, Temperature, CalledFrom); } - + //***************************************************************************** Real64 GlycolProps::getViscosity(EnergyPlusData &state, - Real64 const Temp, // actual temperature given as input - std::string_view const CalledFrom // routine this function was called from (error messages) + Real64 const Temp, // actual temperature given as input + std::string_view const CalledFrom // routine this function was called from (error messages) ) { @@ -4399,15 +4435,16 @@ namespace FluidProperties { Visc = this->ViscValues(this->ViscHighTempIndex); } else { // Temperature somewhere between the lowest and highest value #ifdef PERFORMANCE_OPT - if (Temp < this->ViscTemps(this->LoViscTempIdxLast) || Temp > this->ViscTemps(this->LoViscTempIdxLast+1)) { + if (Temp < this->ViscTemps(this->LoViscTempIdxLast) || Temp > this->ViscTemps(this->LoViscTempIdxLast + 1)) { this->LoViscTempIdxLast = FindArrayIndex(Temp, this->ViscTemps, 1, this->NumViscTempPoints); } - Visc = this->ViscValues(this->LoViscTempIdxLast) + (Temp - this->ViscTemps(this->LoViscTempIdxLast)) * this->ViscTempRatios(this->LoViscTempIdxLast); -#else // !PERFORMANCE_OPT + Visc = this->ViscValues(this->LoViscTempIdxLast) + + (Temp - this->ViscTemps(this->LoViscTempIdxLast)) * this->ViscTempRatios(this->LoViscTempIdxLast); +#else // !PERFORMANCE_OPT int LoTempIndex = FindArrayIndex(Temp, this->ViscTemps, 1, this->NumViscTempPoints); - Real64 TempInterpRatio = (Temp - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex+1) - this->ViscTemps(LoTempIndex)); - Visc = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex+1) - this->ViscValues(LoTempIndex)); -#endif // PERFORMANCE_OPT + Real64 TempInterpRatio = (Temp - this->ViscTemps(LoTempIndex)) / (this->ViscTemps(LoTempIndex + 1) - this->ViscTemps(LoTempIndex)); + Visc = this->ViscValues(LoTempIndex) + TempInterpRatio * (this->ViscValues(LoTempIndex + 1) - this->ViscValues(LoTempIndex)); +#endif // PERFORMANCE_OPT } // Error handling @@ -4416,7 +4453,8 @@ namespace FluidProperties { if (error == GlycolError::ViscosityHigh) { if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too low) for fluid [{}] viscosity **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too low) for fluid [{}] viscosity **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4432,10 +4470,11 @@ namespace FluidProperties { Temp, "{C}"); } - + else if (error == GlycolError::ViscosityHigh) { if (df->glycolErrorLimits[(int)error] <= df->GlycolErrorLimitTest) { - ShowWarningMessage(state, format("{}: Temperature is out of range (too high) for fluid [{}] viscosity **", routineName, this->Name)); + ShowWarningMessage(state, + format("{}: Temperature is out of range (too high) for fluid [{}] viscosity **", routineName, this->Name)); ShowContinueError(state, format("..Called From:{},Temperature=[{:.2R}], supplied data range=[{:.2R},{:.2R}]", CalledFrom, @@ -4457,15 +4496,15 @@ namespace FluidProperties { } // GlycolProps::getViscosity() Real64 GetViscosityGlycol(EnergyPlusData &state, - std::string_view const glycolName, // carries in substance name - Real64 const Temperature, // actual temperature given as input - int &GlycolIndex, // Index to Glycol Properties - std::string_view const CalledFrom // routine this function was called from (error messages) + std::string_view const glycolName, // carries in substance name + Real64 const Temperature, // actual temperature given as input + int &GlycolIndex, // Index to Glycol Properties + std::string_view const CalledFrom // routine this function was called from (error messages) ) { // Wrapper for GlycolProps::getViscosity() auto &df = state.dataFluidProps; - + if (GlycolIndex == 0) { if ((GlycolIndex = GetGlycolNum(state, glycolName)) == 0) { ShowSevereError(state, format("Glycol \"{}\" not found, called from: {}", glycolName, CalledFrom)); @@ -4477,7 +4516,7 @@ namespace FluidProperties { // Now determine the value of specific heat using interpolation return df->glycols(GlycolIndex)->getViscosity(state, Temperature, CalledFrom); } - + //***************************************************************************** int GetRefrigNum(EnergyPlusData &state, std::string_view const refrigName) // carries in substance name @@ -4491,9 +4530,9 @@ namespace FluidProperties { // This function simply determines the index of the refrigerant named // in the input variable to this routine within the derived type. auto &df = state.dataFluidProps; - - auto found = std::find_if(df->refrigs.begin(), df->refrigs.end(), - [refrigName](RefrigProps const *refrig) { return refrig->Name == refrigName; }); + + auto found = + std::find_if(df->refrigs.begin(), df->refrigs.end(), [refrigName](RefrigProps const *refrig) { return refrig->Name == refrigName; }); if (found == df->refrigs.end()) return 0; @@ -4502,7 +4541,8 @@ namespace FluidProperties { return refrigNum; } - RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view const refrigName) { + RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view const refrigName) + { auto &df = state.dataFluidProps; int refrigNum = GetRefrigNum(state, refrigName); return (refrigNum > 0) ? df->refrigs(refrigNum) : nullptr; @@ -4521,9 +4561,9 @@ namespace FluidProperties { // This function simply determines the index of the glycol named // in the input variable to this routine within the derived type. auto &df = state.dataFluidProps; - - auto found = std::find_if(df->glycols.begin(), df->glycols.end(), - [glycolName](GlycolProps const *glycol) { return glycol->Name == glycolName; }); + + auto found = + std::find_if(df->glycols.begin(), df->glycols.end(), [glycolName](GlycolProps const *glycol) { return glycol->Name == glycolName; }); if (found == df->glycols.end()) return 0; @@ -4532,7 +4572,8 @@ namespace FluidProperties { return glycolNum; } - GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view const glycolName) { + GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view const glycolName) + { auto &df = state.dataFluidProps; int glycolNum = GetGlycolNum(state, glycolName); return (glycolNum > 0) ? df->glycols(glycolNum) : nullptr; @@ -4541,9 +4582,10 @@ namespace FluidProperties { int GetGlycolRawNum(EnergyPlusData &state, std::string_view const glycolRawName) // carries in substance name { auto &df = state.dataFluidProps; - - auto found = std::find_if(df->glycolsRaw.begin(), df->glycolsRaw.end(), - [glycolRawName](GlycolRawProps const *glycolRaw) { return glycolRaw->Name == glycolRawName; }); + + auto found = std::find_if(df->glycolsRaw.begin(), df->glycolsRaw.end(), [glycolRawName](GlycolRawProps const *glycolRaw) { + return glycolRaw->Name == glycolRawName; + }); if (found == df->glycolsRaw.end()) return 0; @@ -4551,12 +4593,13 @@ namespace FluidProperties { return glycolRawNum; } - GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view const glycolRawName) { + GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view const glycolRawName) + { auto &df = state.dataFluidProps; int glycolRawNum = GetGlycolRawNum(state, glycolRawName); return (glycolRawNum > 0) ? df->glycolsRaw(glycolRawNum) : nullptr; } - + //***************************************************************************** std::string GetGlycolNameByIndex(EnergyPlusData &state, int const Idx) // carries in substance index @@ -4725,7 +4768,7 @@ namespace FluidProperties { Real64 ReturnValue; auto &df = state.dataFluidProps; - + // error counters and dummy string bool ErrorFlag(false); // error flag for current call @@ -4778,7 +4821,7 @@ namespace FluidProperties { //***************************************************************************** bool CheckFluidPropertyName(EnergyPlusData &state, - std::string const &name) // Name from input(?) to be checked against valid FluidPropertyNames + std::string const &name) // Name from input(?) to be checked against valid FluidPropertyNames { // FUNCTION INFORMATION: @@ -4788,11 +4831,11 @@ namespace FluidProperties { // PURPOSE OF THIS FUNCTION: // This function checks on an input fluid property to make sure it is valid. auto &df = state.dataFluidProps; - - auto foundRefrig = std::find_if(df->refrigs.begin(), df->refrigs.end(), [name](RefrigProps const *refrig){ return refrig->Name == name; }); + + auto foundRefrig = std::find_if(df->refrigs.begin(), df->refrigs.end(), [name](RefrigProps const *refrig) { return refrig->Name == name; }); if (foundRefrig != df->refrigs.end()) return true; - auto foundGlycol = std::find_if(df->glycols.begin(), df->glycols.end(), [name](GlycolProps const *glycol){ return glycol->Name == name; }); + auto foundGlycol = std::find_if(df->glycols.begin(), df->glycols.end(), [name](GlycolProps const *glycol) { return glycol->Name == name; }); if (foundGlycol != df->glycols.end()) return true; return false; @@ -4813,7 +4856,7 @@ namespace FluidProperties { int NumUnusedRefrig = 0; auto &df = state.dataFluidProps; - + for (auto const *refrig : df->refrigs) { if (refrig->used) continue; if (refrig->Name == "STEAM") continue; @@ -4855,7 +4898,6 @@ namespace FluidProperties { } } - void GetFluidDensityTemperatureLimits(EnergyPlusData &state, int const FluidIndex, Real64 &MinTempLimit, Real64 &MaxTempLimit) { if (FluidIndex > 0) { @@ -4944,1944 +4986,1961 @@ namespace FluidProperties { #ifdef UNUSED_FLUID_PROPS static constexpr std::array, DefaultNumSteamSuperheatedPressure> - DefaultSteamSuperheatedEnthalpyDataTable = { - {{2501000.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 2510000.0, 2519000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 2519000.0, 2529000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 2528000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, - 2604000.0, 2613000.0, 2622000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 2537000.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, - 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2584000.0, 2594000.0, - 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, - 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2702000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2556000.0, 2565000.0, 2575000.0, 2584000.0, 2594000.0, - 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, - 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2698000.0, 2700000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2565000.0, 2574000.0, 2584000.0, 2593000.0, - 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2661000.0, - 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2574000.0, 2583000.0, 2593000.0, - 2602000.0, 2612000.0, 2621000.0, 2631000.0, 2635000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2657000.0, 2661000.0, - 2665000.0, 2669000.0, 2673000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, - 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2582000.0, 2592000.0, - 2602000.0, 2611000.0, 2621000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2649000.0, 2653000.0, 2657000.0, 2661000.0, - 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2775000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2795000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2591000.0, - 2601000.0, 2611000.0, 2620000.0, 2630000.0, 2634000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, 2660000.0, - 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, - 2697000.0, 2699000.0, 2701000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, - 2720000.0, 2722000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, - 2743000.0, 2745000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, - 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2600000.0, 2610000.0, 2620000.0, 2629000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2648000.0, 2652000.0, 2656000.0, 2660000.0, - 2664000.0, 2668000.0, 2671000.0, 2675000.0, 2679000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2692000.0, 2694000.0, - 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2715000.0, 2717000.0, - 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, 2740000.0, - 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, - 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, - 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2609000.0, 2619000.0, 2628000.0, 2632000.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2655000.0, 2659000.0, - 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, - 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, - 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, - 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2778000.0, 2782000.0, - 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, - 2833000.0, 2836000.0, 2840000.0, 2850000.0, 2860000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2908000.0, 2918000.0, 2928000.0, - 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3076000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2618000.0, 2627000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2659000.0, - 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, - 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2716000.0, - 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, - 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, - 2786000.0, 2790000.0, 2794000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2850000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, - 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3117000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2626000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, - 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, - 2695000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, - 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, - 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, - 2937000.0, 2957000.0, 2977000.0, 2997000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, - 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2630000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, - 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, - 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, - 2741000.0, 2743000.0, 2747000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, - 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, - 2661000.0, 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, - 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2832000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, - 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, - 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2789000.0, 2793000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2917000.0, 2927000.0, - 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, - 2660000.0, 2664000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, - 2785000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, - 2659000.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, - 2693000.0, 2695000.0, 2697000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, - 2740000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2646000.0, 2650000.0, 2654000.0, - 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, - 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, - 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, - 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2835000.0, 2839000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2650000.0, 2654000.0, - 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, - 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, - 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, - 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, - 2784000.0, 2788000.0, 2792000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, - 2831000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2653000.0, - 2657000.0, 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, - 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, - 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2732000.0, 2734000.0, 2736000.0, - 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2926000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3035000.0, 3055000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, - 3177000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2656000.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, - 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, - 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, - 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2916000.0, 2926000.0, - 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, - 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, - 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2735000.0, - 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, - 2783000.0, 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2830000.0, 2834000.0, 2838000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2936000.0, 2956000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, - 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, - 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, - 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2774000.0, 2778000.0, - 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, - 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2936000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2666000.0, 2670000.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, - 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, - 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, - 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, - 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, - 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, - 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2669000.0, 2673000.0, 2675000.0, 2677000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, - 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, - 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, - 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, - 2829000.0, 2833000.0, 2837000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2672000.0, 2674000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, - 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, - 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, - 2686000.0, 2688000.0, 2690000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, - 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, - 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2975000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, - 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, - 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2955000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, - 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2935000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2679000.0, 2681000.0, 2683000.0, - 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2706000.0, 2708000.0, - 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, - 2828000.0, 2832000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2680000.0, 2682000.0, - 2684000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, - 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, 2732000.0, - 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, - 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2682000.0, - 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, - 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, - 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, - 3176000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2683000.0, 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, - 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, - 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, - 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, - 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, - 2827000.0, 2831000.0, 2835000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2686000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, - 2707000.0, 2709000.0, 2711000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, - 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, - 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, - 2934000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, - 2706000.0, 2708000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, - 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, - 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, - 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2727000.0, 2729000.0, - 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, - 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, - 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, - 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2703000.0, - 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2724000.0, 2726000.0, 2728000.0, - 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, 2773000.0, - 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, - 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, - 2729000.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, - 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, - 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2697000.0, 2699000.0, 2701000.0, - 2703000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2725000.0, 2727000.0, - 2729000.0, 2731000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2699000.0, 2701000.0, - 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, - 2728000.0, 2730000.0, 2734000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, - 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3174000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2700000.0, - 2702000.0, 2704000.0, 2706000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2726000.0, - 2728000.0, 2730000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, - 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, - 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, - 2727000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2771000.0, - 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, - 2726000.0, 2729000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, - 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2922000.0, - 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2704000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, 2722000.0, 2724000.0, - 2726000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2766000.0, 2770000.0, - 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, 2815000.0, 2819000.0, - 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, - 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, - 2725000.0, 2727000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, - 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2707000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, - 2725000.0, 2727000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, - 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2718000.0, 2720000.0, 2722000.0, - 2724000.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, - 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2818000.0, - 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2921000.0, - 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3488000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, - 2723000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, 2768000.0, - 2772000.0, 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, - 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, - 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, - 2723000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, - 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2813000.0, 2817000.0, - 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2970000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, - 2722000.0, 2724000.0, 2728000.0, 2733000.0, 2737000.0, 2741000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2767000.0, - 2771000.0, 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, - 2820000.0, 2824000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2900000.0, 2910000.0, 2920000.0, - 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2715000.0, 2717000.0, 2719000.0, - 2721000.0, 2723000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2758000.0, 2762000.0, 2766000.0, - 2770000.0, 2774000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, 2816000.0, - 2820000.0, 2824000.0, 2828000.0, 2838000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, - 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3010000.0, 3031000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3153000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2716000.0, 2718000.0, - 2720000.0, 2723000.0, 2727000.0, 2731000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, - 2770000.0, 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, - 2819000.0, 2824000.0, 2828000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, - 2929000.0, 2949000.0, 2970000.0, 2990000.0, 3010000.0, 3030000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3152000.0, - 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2717000.0, - 2720000.0, 2722000.0, 2726000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2761000.0, 2765000.0, - 2769000.0, 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2807000.0, 2811000.0, 2815000.0, - 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2899000.0, 2909000.0, 2919000.0, - 2929000.0, 2949000.0, 2969000.0, 2990000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2719000.0, 2721000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, - 2768000.0, 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, - 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2847000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2919000.0, - 2929000.0, 2949000.0, 2969000.0, 2989000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2720000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, - 2768000.0, 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2806000.0, 2810000.0, 2814000.0, - 2818000.0, 2822000.0, 2826000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, - 2928000.0, 2949000.0, 2969000.0, 2989000.0, 3009000.0, 3030000.0, 3050000.0, 3070000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, - 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2723000.0, 2727000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, - 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2805000.0, 2809000.0, 2813000.0, - 2817000.0, 2821000.0, 2825000.0, 2836000.0, 2846000.0, 2856000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2918000.0, - 2928000.0, 2948000.0, 2968000.0, 2989000.0, 3009000.0, 3029000.0, 3050000.0, 3070000.0, 3090000.0, 3111000.0, 3131000.0, 3152000.0, - 3172000.0, 3193000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, 2757000.0, 2761000.0, - 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, - 2816000.0, 2820000.0, 2824000.0, 2835000.0, 2845000.0, 2855000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2907000.0, 2917000.0, - 2927000.0, 2947000.0, 2968000.0, 2988000.0, 3008000.0, 3029000.0, 3049000.0, 3069000.0, 3090000.0, 3110000.0, 3131000.0, 3151000.0, - 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2728000.0, 2733000.0, 2737000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, - 2764000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, - 2815000.0, 2819000.0, 2823000.0, 2834000.0, 2844000.0, 2854000.0, 2865000.0, 2875000.0, 2885000.0, 2896000.0, 2906000.0, 2916000.0, - 2926000.0, 2947000.0, 2967000.0, 2987000.0, 3008000.0, 3028000.0, 3049000.0, 3069000.0, 3089000.0, 3110000.0, 3130000.0, 3151000.0, - 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2749000.0, 2753000.0, 2758000.0, - 2762000.0, 2767000.0, 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, - 2814000.0, 2818000.0, 2822000.0, 2833000.0, 2843000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, - 2926000.0, 2946000.0, 2966000.0, 2987000.0, 3007000.0, 3028000.0, 3048000.0, 3069000.0, 3089000.0, 3109000.0, 3130000.0, 3151000.0, - 3171000.0, 3192000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2733000.0, 2738000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, - 2761000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, - 2812000.0, 2817000.0, 2821000.0, 2831000.0, 2842000.0, 2852000.0, 2863000.0, 2873000.0, 2884000.0, 2894000.0, 2904000.0, 2915000.0, - 2925000.0, 2945000.0, 2966000.0, 2986000.0, 3007000.0, 3027000.0, 3048000.0, 3068000.0, 3089000.0, 3109000.0, 3130000.0, 3150000.0, - 3171000.0, 3191000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2736000.0, 2741000.0, 2745000.0, 2750000.0, 2754000.0, - 2759000.0, 2763000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2803000.0, 2807000.0, - 2811000.0, 2815000.0, 2820000.0, 2830000.0, 2841000.0, 2851000.0, 2862000.0, 2872000.0, 2883000.0, 2893000.0, 2903000.0, 2914000.0, - 2924000.0, 2945000.0, 2965000.0, 2986000.0, 3006000.0, 3027000.0, 3047000.0, 3068000.0, 3088000.0, 3109000.0, 3129000.0, 3150000.0, - 3170000.0, 3191000.0, 3212000.0, 3280000.0, 3379000.0, 3486000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, - 2757000.0, 2761000.0, 2766000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, - 2810000.0, 2814000.0, 2818000.0, 2829000.0, 2840000.0, 2850000.0, 2861000.0, 2871000.0, 2882000.0, 2892000.0, 2902000.0, 2913000.0, - 2923000.0, 2944000.0, 2964000.0, 2985000.0, 3005000.0, 3026000.0, 3046000.0, 3067000.0, 3088000.0, 3108000.0, 3129000.0, 3149000.0, - 3170000.0, 3191000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2741000.0, 2746000.0, 2750000.0, - 2755000.0, 2760000.0, 2764000.0, 2769000.0, 2773000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, - 2808000.0, 2813000.0, 2817000.0, 2828000.0, 2838000.0, 2849000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2912000.0, - 2922000.0, 2943000.0, 2964000.0, 2984000.0, 3005000.0, 3025000.0, 3046000.0, 3066000.0, 3087000.0, 3108000.0, 3128000.0, 3149000.0, - 3170000.0, 3190000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2744000.0, 2748000.0, - 2753000.0, 2758000.0, 2762000.0, 2767000.0, 2771000.0, 2776000.0, 2780000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, - 2807000.0, 2811000.0, 2815000.0, 2826000.0, 2837000.0, 2848000.0, 2858000.0, 2869000.0, 2879000.0, 2890000.0, 2900000.0, 2911000.0, - 2921000.0, 2942000.0, 2963000.0, 2983000.0, 3004000.0, 3025000.0, 3045000.0, 3066000.0, 3086000.0, 3107000.0, 3128000.0, 3148000.0, - 3169000.0, 3190000.0, 3211000.0, 3280000.0, 3378000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2746000.0, - 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2801000.0, - 2805000.0, 2810000.0, 2814000.0, 2825000.0, 2836000.0, 2846000.0, 2857000.0, 2868000.0, 2878000.0, 2889000.0, 2899000.0, 2910000.0, - 2920000.0, 2941000.0, 2962000.0, 2983000.0, 3003000.0, 3024000.0, 3045000.0, 3065000.0, 3086000.0, 3106000.0, 3127000.0, 3148000.0, - 3169000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3485000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2748000.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2776000.0, 2781000.0, 2786000.0, 2790000.0, 2795000.0, 2799000.0, - 2803000.0, 2808000.0, 2812000.0, 2823000.0, 2834000.0, 2845000.0, 2856000.0, 2866000.0, 2877000.0, 2888000.0, 2898000.0, 2909000.0, - 2919000.0, 2940000.0, 2961000.0, 2982000.0, 3002000.0, 3023000.0, 3044000.0, 3064000.0, 3085000.0, 3106000.0, 3127000.0, 3147000.0, - 3168000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, - 2802000.0, 2806000.0, 2811000.0, 2822000.0, 2833000.0, 2843000.0, 2854000.0, 2865000.0, 2876000.0, 2886000.0, 2897000.0, 2908000.0, - 2918000.0, 2939000.0, 2960000.0, 2981000.0, 3002000.0, 3022000.0, 3043000.0, 3064000.0, 3085000.0, 3105000.0, 3126000.0, 3147000.0, - 3168000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, 2791000.0, 2795000.0, - 2800000.0, 2804000.0, 2809000.0, 2820000.0, 2831000.0, 2842000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2896000.0, 2906000.0, - 2917000.0, 2938000.0, 2959000.0, 2980000.0, 3001000.0, 3022000.0, 3042000.0, 3063000.0, 3084000.0, 3105000.0, 3125000.0, 3146000.0, - 3167000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2789000.0, 2793000.0, - 2798000.0, 2802000.0, 2807000.0, 2818000.0, 2829000.0, 2840000.0, 2851000.0, 2862000.0, 2873000.0, 2884000.0, 2894000.0, 2905000.0, - 2916000.0, 2937000.0, 2958000.0, 2979000.0, 3000000.0, 3021000.0, 3042000.0, 3062000.0, 3083000.0, 3104000.0, 3125000.0, 3146000.0, - 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3377000.0, 3484000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2757000.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2782000.0, 2786000.0, 2791000.0, - 2796000.0, 2800000.0, 2805000.0, 2816000.0, 2827000.0, 2839000.0, 2850000.0, 2861000.0, 2872000.0, 2882000.0, 2893000.0, 2904000.0, - 2915000.0, 2936000.0, 2957000.0, 2978000.0, 2999000.0, 3020000.0, 3041000.0, 3062000.0, 3082000.0, 3103000.0, 3124000.0, 3145000.0, - 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3376000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2789000.0, - 2793000.0, 2798000.0, 2803000.0, 2814000.0, 2826000.0, 2837000.0, 2848000.0, 2859000.0, 2870000.0, 2881000.0, 2892000.0, 2902000.0, - 2913000.0, 2935000.0, 2956000.0, 2977000.0, 2998000.0, 3019000.0, 3040000.0, 3061000.0, 3082000.0, 3102000.0, 3123000.0, 3144000.0, - 3165000.0, 3186000.0, 3207000.0, 3280000.0, 3376000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, - 2791000.0, 2796000.0, 2800000.0, 2812000.0, 2824000.0, 2835000.0, 2846000.0, 2857000.0, 2868000.0, 2879000.0, 2890000.0, 2901000.0, - 2912000.0, 2933000.0, 2955000.0, 2976000.0, 2997000.0, 3018000.0, 3039000.0, 3060000.0, 3081000.0, 3102000.0, 3123000.0, 3144000.0, - 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3483000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2764000.0, 2769000.0, 2774000.0, 2779000.0, 2784000.0, - 2789000.0, 2793000.0, 2798000.0, 2810000.0, 2821000.0, 2833000.0, 2844000.0, 2855000.0, 2867000.0, 2878000.0, 2889000.0, 2900000.0, - 2910000.0, 2932000.0, 2953000.0, 2975000.0, 2996000.0, 3017000.0, 3038000.0, 3059000.0, 3080000.0, 3101000.0, 3122000.0, 3143000.0, - 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3482000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2766000.0, 2771000.0, 2776000.0, 2781000.0, - 2786000.0, 2791000.0, 2796000.0, 2808000.0, 2819000.0, 2831000.0, 2842000.0, 2854000.0, 2865000.0, 2876000.0, 2887000.0, 2898000.0, - 2909000.0, 2931000.0, 2952000.0, 2973000.0, 2995000.0, 3016000.0, 3037000.0, 3058000.0, 3079000.0, 3100000.0, 3121000.0, 3142000.0, - 3163000.0, 3184000.0, 3205000.0, 3280000.0, 3374000.0, 3482000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2768000.0, 2773000.0, 2778000.0, - 2783000.0, 2788000.0, 2793000.0, 2805000.0, 2817000.0, 2829000.0, 2840000.0, 2852000.0, 2863000.0, 2874000.0, 2885000.0, 2896000.0, - 2907000.0, 2929000.0, 2951000.0, 2972000.0, 2994000.0, 3015000.0, 3036000.0, 3057000.0, 3078000.0, 3099000.0, 3120000.0, 3141000.0, - 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3374000.0, 3481000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2770000.0, 2775000.0, - 2780000.0, 2785000.0, 2790000.0, 2802000.0, 2814000.0, 2826000.0, 2838000.0, 2850000.0, 2861000.0, 2872000.0, 2883000.0, 2895000.0, - 2906000.0, 2928000.0, 2949000.0, 2971000.0, 2992000.0, 3014000.0, 3035000.0, 3056000.0, 3077000.0, 3098000.0, 3119000.0, 3140000.0, - 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3373000.0, 3481000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2772000.0, - 2777000.0, 2782000.0, 2787000.0, 2800000.0, 2812000.0, 2824000.0, 2836000.0, 2847000.0, 2859000.0, 2870000.0, 2882000.0, 2893000.0, - 2904000.0, 2926000.0, 2948000.0, 2969000.0, 2991000.0, 3012000.0, 3034000.0, 3055000.0, 3076000.0, 3097000.0, 3118000.0, 3140000.0, - 3161000.0, 3182000.0, 3203000.0, 3280000.0, 3373000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2774000.0, 2779000.0, 2784000.0, 2797000.0, 2809000.0, 2821000.0, 2833000.0, 2845000.0, 2857000.0, 2868000.0, 2880000.0, 2891000.0, - 2902000.0, 2924000.0, 2946000.0, 2968000.0, 2990000.0, 3011000.0, 3033000.0, 3054000.0, 3075000.0, 3096000.0, 3118000.0, 3139000.0, - 3160000.0, 3181000.0, 3202000.0, 3280000.0, 3372000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2775000.0, 2781000.0, 2794000.0, 2806000.0, 2819000.0, 2831000.0, 2843000.0, 2854000.0, 2866000.0, 2878000.0, 2889000.0, - 2900000.0, 2923000.0, 2945000.0, 2967000.0, 2988000.0, 3010000.0, 3031000.0, 3053000.0, 3074000.0, 3095000.0, 3117000.0, 3138000.0, - 3159000.0, 3180000.0, 3201000.0, 3280000.0, 3372000.0, 3480000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2777000.0, 2790000.0, 2803000.0, 2816000.0, 2828000.0, 2840000.0, 2852000.0, 2864000.0, 2875000.0, 2887000.0, - 2898000.0, 2921000.0, 2943000.0, 2965000.0, 2987000.0, 3009000.0, 3030000.0, 3052000.0, 3073000.0, 3094000.0, 3116000.0, 3137000.0, - 3158000.0, 3179000.0, 3201000.0, 3280000.0, 3371000.0, 3479000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2781000.0, 2795000.0, 2808000.0, 2821000.0, 2833000.0, 2846000.0, 2858000.0, 2870000.0, 2881000.0, - 2893000.0, 2916000.0, 2939000.0, 2961000.0, 2983000.0, 3005000.0, 3027000.0, 3048000.0, 3070000.0, 3091000.0, 3113000.0, 3134000.0, - 3156000.0, 3177000.0, 3198000.0, 3280000.0, 3370000.0, 3478000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2785000.0, 2799000.0, 2813000.0, 2826000.0, 2838000.0, 2851000.0, 2863000.0, 2875000.0, - 2887000.0, 2910000.0, 2933000.0, 2956000.0, 2979000.0, 3001000.0, 3023000.0, 3045000.0, 3067000.0, 3088000.0, 3110000.0, 3132000.0, - 3153000.0, 3175000.0, 3196000.0, 3280000.0, 3368000.0, 3476000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2789000.0, 2803000.0, 2817000.0, 2830000.0, 2843000.0, 2856000.0, 2868000.0, - 2880000.0, 2904000.0, 2928000.0, 2951000.0, 2974000.0, 2996000.0, 3019000.0, 3041000.0, 3063000.0, 3085000.0, 3107000.0, 3128000.0, - 3150000.0, 3172000.0, 3193000.0, 3280000.0, 3366000.0, 3475000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2792000.0, 2807000.0, 2821000.0, 2834000.0, 2847000.0, 2860000.0, - 2873000.0, 2898000.0, 2922000.0, 2945000.0, 2969000.0, 2992000.0, 3014000.0, 3037000.0, 3059000.0, 3081000.0, 3103000.0, 3125000.0, - 3147000.0, 3169000.0, 3190000.0, 3280000.0, 3364000.0, 3473000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2795000.0, 2810000.0, 2824000.0, 2838000.0, 2851000.0, - 2864000.0, 2890000.0, 2915000.0, 2939000.0, 2963000.0, 2986000.0, 3009000.0, 3032000.0, 3055000.0, 3077000.0, 3099000.0, 3121000.0, - 3143000.0, 3165000.0, 3187000.0, 3280000.0, 3362000.0, 3471000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2797000.0, 2813000.0, 2827000.0, 2841000.0, - 2855000.0, 2882000.0, 2907000.0, 2932000.0, 2956000.0, 2980000.0, 3004000.0, 3027000.0, 3050000.0, 3072000.0, 3095000.0, 3117000.0, - 3140000.0, 3162000.0, 3184000.0, 3280000.0, 3359000.0, 3469000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2799000.0, 2815000.0, 2830000.0, - 2844000.0, 2872000.0, 2899000.0, 2924000.0, 2949000.0, 2974000.0, 2998000.0, 3021000.0, 3044000.0, 3067000.0, 3090000.0, 3113000.0, - 3135000.0, 3158000.0, 3180000.0, 3280000.0, 3357000.0, 3467000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2801000.0, 2817000.0, - 2832000.0, 2862000.0, 2889000.0, 2916000.0, 2941000.0, 2966000.0, 2991000.0, 3015000.0, 3039000.0, 3062000.0, 3085000.0, 3108000.0, - 3131000.0, 3154000.0, 3176000.0, 3280000.0, 3354000.0, 3465000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2802000.0, - 2819000.0, 2850000.0, 2879000.0, 2906000.0, 2933000.0, 2958000.0, 2984000.0, 3008000.0, 3032000.0, 3056000.0, 3080000.0, 3103000.0, - 3126000.0, 3149000.0, 3172000.0, 3280000.0, 3351000.0, 3462000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 2803000.0, 2836000.0, 2867000.0, 2895000.0, 2923000.0, 2950000.0, 2975000.0, 3001000.0, 3025000.0, 3050000.0, 3073000.0, 3097000.0, - 3121000.0, 3144000.0, 3167000.0, 3280000.0, 3348000.0, 3459000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 2803000.0, 2838000.0, 2870000.0, 2900000.0, 2929000.0, 2957000.0, 2983000.0, 3009000.0, 3035000.0, 3060000.0, 3084000.0, - 3108000.0, 3132000.0, 3156000.0, 3280000.0, 3340000.0, 3453000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 2801000.0, 2838000.0, 2872000.0, 2904000.0, 2934000.0, 2963000.0, 2990000.0, 3017000.0, 3043000.0, 3069000.0, - 3094000.0, 3119000.0, 3143000.0, 3280000.0, 3332000.0, 3446000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2797000.0, 2837000.0, 2873000.0, 2906000.0, 2937000.0, 2967000.0, 2996000.0, 3023000.0, 3050000.0, - 3077000.0, 3103000.0, 3128000.0, 3280000.0, 3322000.0, 3438000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2790000.0, 2833000.0, 2871000.0, 2906000.0, 2939000.0, 2970000.0, 3000000.0, 3029000.0, - 3057000.0, 3084000.0, 3110000.0, 3280000.0, 3310000.0, 3429000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 2780000.0, 2826000.0, 2867000.0, 2905000.0, 2939000.0, 2972000.0, 3003000.0, - 3033000.0, 3062000.0, 3090000.0, 3280000.0, 3297000.0, 3418000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2767000.0, 2817000.0, - 2861000.0, 2901000.0, 2938000.0, 2972000.0, 3004000.0, 3036000.0, 3066000.0, 3280000.0, 3282000.0, 3406000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2750000.0, - 2806000.0, 2853000.0, 2895000.0, 2934000.0, 2970000.0, 3004000.0, 3037000.0, 3280000.0, 3264000.0, 3392000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2728000.0, - 2790000.0, 2842000.0, 2887000.0, 2929000.0, 2967000.0, 3003000.0, 3280000.0, 3244000.0, 3377000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 2701000.0, 2771000.0, 2828000.0, 2877000.0, 2921000.0, 2961000.0, 3280000.0, 3222000.0, 3359000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 2666000.0, 2747000.0, 2810000.0, 2864000.0, 2911000.0, 3280000.0, 3195000.0, 3339000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2622000.0, 2718000.0, 2789000.0, 2847000.0, 3280000.0, 3165000.0, 3316000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2564000.0, 2683000.0, 2763000.0, 3280000.0, 3130000.0, 3290000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2481000.0, 2641000.0, 3280000.0, 3089000.0, 3260000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2335000.0, 3280000.0, 3040000.0, 3226000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2821000.0, 3085000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2671000.0, 2998000.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2512000.0, 2906000.0}} - }; - + DefaultSteamSuperheatedEnthalpyDataTable = { + {{2501000.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 2503000.0, 2510000.0, 2520000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2595000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2746000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 2510000.0, 2519000.0, 2529000.0, 2538000.0, 2548000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2640000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2788000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 2519000.0, 2529000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2576000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2623000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2689000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 2528000.0, 2538000.0, 2547000.0, 2557000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, + 2604000.0, 2613000.0, 2622000.0, 2632000.0, 2636000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2670000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2744000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 2537000.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2585000.0, 2594000.0, + 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2687000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2742000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2834000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2547000.0, 2556000.0, 2566000.0, 2575000.0, 2584000.0, 2594000.0, + 2603000.0, 2613000.0, 2622000.0, 2632000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, + 2666000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2685000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2702000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2784000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2861000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2556000.0, 2565000.0, 2575000.0, 2584000.0, 2594000.0, + 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2662000.0, + 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2698000.0, 2700000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2830000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2565000.0, 2574000.0, 2584000.0, 2593000.0, + 2603000.0, 2612000.0, 2622000.0, 2631000.0, 2635000.0, 2639000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, 2661000.0, + 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2899000.0, 2909000.0, 2919000.0, 2929000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2574000.0, 2583000.0, 2593000.0, + 2602000.0, 2612000.0, 2621000.0, 2631000.0, 2635000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2657000.0, 2661000.0, + 2665000.0, 2669000.0, 2673000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2753000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, + 2938000.0, 2958000.0, 2978000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2582000.0, 2592000.0, + 2602000.0, 2611000.0, 2621000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2649000.0, 2653000.0, 2657000.0, 2661000.0, + 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2775000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2795000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2851000.0, 2860000.0, 2870000.0, 2880000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2591000.0, + 2601000.0, 2611000.0, 2620000.0, 2630000.0, 2634000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, 2660000.0, + 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, + 2697000.0, 2699000.0, 2701000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, + 2720000.0, 2722000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, 2741000.0, + 2743000.0, 2745000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, + 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3178000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2600000.0, 2610000.0, 2620000.0, 2629000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2648000.0, 2652000.0, 2656000.0, 2660000.0, + 2664000.0, 2668000.0, 2671000.0, 2675000.0, 2679000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2692000.0, 2694000.0, + 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2715000.0, 2717000.0, + 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, 2740000.0, + 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2783000.0, + 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2837000.0, 2841000.0, 2850000.0, 2860000.0, 2870000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2918000.0, 2928000.0, + 2938000.0, 2958000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3077000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2609000.0, 2619000.0, 2628000.0, 2632000.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2655000.0, 2659000.0, + 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, + 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, + 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, + 2742000.0, 2744000.0, 2748000.0, 2752000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2778000.0, 2782000.0, + 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2829000.0, + 2833000.0, 2836000.0, 2840000.0, 2850000.0, 2860000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2908000.0, 2918000.0, 2928000.0, + 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3037000.0, 3057000.0, 3076000.0, 3097000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2618000.0, 2627000.0, 2631000.0, 2635000.0, 2639000.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, 2659000.0, + 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2689000.0, 2691000.0, 2693000.0, + 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2716000.0, + 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, 2740000.0, + 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, + 2786000.0, 2790000.0, 2794000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2850000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, + 2938000.0, 2957000.0, 2977000.0, 2997000.0, 3017000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3117000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3490000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2626000.0, 2630000.0, 2634000.0, 2638000.0, 2642000.0, 2646000.0, 2650000.0, 2654000.0, 2658000.0, + 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, + 2695000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, + 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, + 2741000.0, 2743000.0, 2747000.0, 2751000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, 2782000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2928000.0, + 2937000.0, 2957000.0, 2977000.0, 2997000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, + 3177000.0, 3198000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2630000.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, + 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2681000.0, 2683000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, + 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2739000.0, + 2741000.0, 2743000.0, 2747000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2836000.0, 2840000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, + 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3137000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2633000.0, 2637000.0, 2641000.0, 2645000.0, 2649000.0, 2653000.0, 2657000.0, + 2661000.0, 2665000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, + 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2832000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, 2927000.0, + 2937000.0, 2957000.0, 2977000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2636000.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, + 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2789000.0, 2793000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, 2828000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2917000.0, 2927000.0, + 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2640000.0, 2644000.0, 2648000.0, 2652000.0, 2656000.0, + 2660000.0, 2664000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2742000.0, 2746000.0, 2750000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2781000.0, + 2785000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2859000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2957000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2643000.0, 2647000.0, 2651000.0, 2655000.0, + 2659000.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, + 2693000.0, 2695000.0, 2697000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, 2738000.0, + 2740000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2849000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3157000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3384000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2646000.0, 2650000.0, 2654000.0, + 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, + 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, + 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, + 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2835000.0, 2839000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2937000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2650000.0, 2654000.0, + 2658000.0, 2662000.0, 2666000.0, 2670000.0, 2674000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, 2690000.0, + 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, + 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, 2737000.0, + 2739000.0, 2741000.0, 2745000.0, 2749000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2780000.0, + 2784000.0, 2788000.0, 2792000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, 2827000.0, + 2831000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2927000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3036000.0, 3056000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3218000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2653000.0, + 2657000.0, 2661000.0, 2665000.0, 2669000.0, 2673000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, 2689000.0, + 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, + 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2732000.0, 2734000.0, 2736000.0, + 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2858000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2917000.0, 2926000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3016000.0, 3035000.0, 3055000.0, 3076000.0, 3096000.0, 3116000.0, 3136000.0, 3156000.0, + 3177000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2656000.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, + 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, + 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2736000.0, + 2738000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2848000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2916000.0, 2926000.0, + 2936000.0, 2956000.0, 2976000.0, 2996000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2660000.0, 2664000.0, 2668000.0, 2672000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, 2688000.0, + 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, + 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, 2735000.0, + 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, 2779000.0, + 2783000.0, 2787000.0, 2791000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2830000.0, 2834000.0, 2838000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2887000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2936000.0, 2956000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3116000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2663000.0, 2667000.0, 2671000.0, 2675000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, 2687000.0, + 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, + 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, 2735000.0, + 2737000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2774000.0, 2778000.0, + 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, 2826000.0, + 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2877000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2936000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2666000.0, 2670000.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, 2686000.0, + 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, + 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, + 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2778000.0, + 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, + 2829000.0, 2833000.0, 2837000.0, 2847000.0, 2857000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2916000.0, 2926000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3136000.0, 3156000.0, + 3176000.0, 3197000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2669000.0, 2673000.0, 2675000.0, 2677000.0, 2679000.0, 2682000.0, 2684000.0, 2686000.0, + 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, + 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, 2734000.0, + 2736000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, 2825000.0, + 2829000.0, 2833000.0, 2837000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2906000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2672000.0, 2674000.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, 2685000.0, + 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, + 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2886000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2995000.0, 3015000.0, 3035000.0, 3055000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2674000.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, + 2686000.0, 2688000.0, 2690000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, + 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2777000.0, + 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2876000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2975000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3075000.0, 3095000.0, 3115000.0, 3135000.0, 3156000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2676000.0, 2678000.0, 2680000.0, 2682000.0, 2684000.0, + 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, 2733000.0, + 2735000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2856000.0, 2866000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2955000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2677000.0, 2679000.0, 2681000.0, 2683000.0, + 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2836000.0, 2846000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2935000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3095000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2679000.0, 2681000.0, 2683000.0, + 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2706000.0, 2708000.0, + 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, 2824000.0, + 2828000.0, 2832000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, 2925000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2680000.0, 2682000.0, + 2684000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, + 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, 2732000.0, + 2734000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, 2776000.0, + 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2895000.0, 2905000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3217000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2682000.0, + 2684000.0, 2686000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2701000.0, 2703000.0, 2705000.0, 2707000.0, + 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, + 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2875000.0, 2885000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3115000.0, 3135000.0, 3155000.0, + 3176000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2683000.0, 2685000.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, + 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, 2731000.0, + 2733000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2845000.0, 2855000.0, 2865000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3489000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2685000.0, 2687000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, 2706000.0, + 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, 2775000.0, + 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, 2823000.0, + 2827000.0, 2831000.0, 2835000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3383000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2686000.0, 2689000.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, + 2707000.0, 2709000.0, 2711000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2954000.0, 2974000.0, 2994000.0, 3014000.0, 3034000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3135000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2688000.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2699000.0, 2701000.0, 2703000.0, 2705000.0, + 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2730000.0, + 2732000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2904000.0, 2914000.0, 2924000.0, + 2934000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3054000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2690000.0, 2692000.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, 2704000.0, + 2706000.0, 2708000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, 2729000.0, + 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, 2774000.0, + 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2854000.0, 2864000.0, 2874000.0, 2884000.0, 2894000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3074000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3196000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2691000.0, 2693000.0, 2695000.0, 2697000.0, 2700000.0, 2702000.0, 2704000.0, + 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2727000.0, 2729000.0, + 2731000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, 2822000.0, + 2826000.0, 2830000.0, 2834000.0, 2844000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3155000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2693000.0, 2695000.0, 2697000.0, 2699000.0, 2701000.0, 2703000.0, + 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, 2728000.0, + 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3094000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2694000.0, 2696000.0, 2698000.0, 2700000.0, 2703000.0, + 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2724000.0, 2726000.0, 2728000.0, + 2730000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, 2773000.0, + 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2696000.0, 2698000.0, 2700000.0, 2702000.0, + 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, 2727000.0, + 2729000.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, 2821000.0, + 2825000.0, 2829000.0, 2833000.0, 2843000.0, 2853000.0, 2863000.0, 2873000.0, 2883000.0, 2893000.0, 2903000.0, 2913000.0, 2923000.0, + 2933000.0, 2953000.0, 2973000.0, 2993000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3114000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2697000.0, 2699000.0, 2701000.0, + 2703000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2725000.0, 2727000.0, + 2729000.0, 2731000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, 2772000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3013000.0, 3033000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3175000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2699000.0, 2701000.0, + 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, 2726000.0, + 2728000.0, 2730000.0, 2734000.0, 2739000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, + 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3053000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3174000.0, 3195000.0, 3216000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2700000.0, + 2702000.0, 2704000.0, 2706000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2726000.0, + 2728000.0, 2730000.0, 2734000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, 2771000.0, + 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, 2820000.0, + 2824000.0, 2828000.0, 2832000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3134000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2702000.0, 2704000.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2714000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, 2725000.0, + 2727000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2771000.0, + 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2842000.0, 2852000.0, 2862000.0, 2872000.0, 2882000.0, 2892000.0, 2902000.0, 2912000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3073000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2703000.0, 2705000.0, 2707000.0, 2709000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, 2724000.0, + 2726000.0, 2729000.0, 2733000.0, 2737000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, 2766000.0, 2770000.0, + 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2922000.0, + 2932000.0, 2952000.0, 2972000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2704000.0, 2707000.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, 2722000.0, 2724000.0, + 2726000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2757000.0, 2761000.0, 2766000.0, 2770000.0, + 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, 2815000.0, 2819000.0, + 2823000.0, 2827000.0, 2831000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2992000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3093000.0, 3113000.0, 3133000.0, 3154000.0, + 3174000.0, 3195000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2706000.0, 2708000.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, 2723000.0, + 2725000.0, 2727000.0, 2732000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, 2769000.0, + 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2841000.0, 2851000.0, 2861000.0, 2871000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3012000.0, 3032000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2707000.0, 2710000.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, 2722000.0, + 2725000.0, 2727000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2760000.0, 2765000.0, 2769000.0, + 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2911000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3113000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3382000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2709000.0, 2711000.0, 2713000.0, 2715000.0, 2718000.0, 2720000.0, 2722000.0, + 2724000.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, 2760000.0, 2764000.0, 2768000.0, + 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2818000.0, + 2822000.0, 2826000.0, 2830000.0, 2840000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2921000.0, + 2931000.0, 2951000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3052000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3488000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2710000.0, 2712000.0, 2715000.0, 2717000.0, 2719000.0, 2721000.0, + 2723000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, 2768000.0, + 2772000.0, 2776000.0, 2780000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, 2813000.0, 2817000.0, + 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2850000.0, 2860000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2971000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3072000.0, 3092000.0, 3112000.0, 3133000.0, 3153000.0, + 3174000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2712000.0, 2714000.0, 2716000.0, 2718000.0, 2720000.0, + 2723000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2750000.0, 2755000.0, 2759000.0, 2763000.0, 2767000.0, + 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2813000.0, 2817000.0, + 2821000.0, 2825000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2870000.0, 2880000.0, 2890000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2970000.0, 2991000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3215000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2713000.0, 2715000.0, 2717000.0, 2720000.0, + 2722000.0, 2724000.0, 2728000.0, 2733000.0, 2737000.0, 2741000.0, 2746000.0, 2750000.0, 2754000.0, 2758000.0, 2762000.0, 2767000.0, + 2771000.0, 2775000.0, 2779000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2800000.0, 2804000.0, 2808000.0, 2812000.0, 2816000.0, + 2820000.0, 2824000.0, 2829000.0, 2839000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2900000.0, 2910000.0, 2920000.0, + 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3011000.0, 3031000.0, 3051000.0, 3071000.0, 3092000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2715000.0, 2717000.0, 2719000.0, + 2721000.0, 2723000.0, 2728000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2753000.0, 2758000.0, 2762000.0, 2766000.0, + 2770000.0, 2774000.0, 2779000.0, 2783000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, 2816000.0, + 2820000.0, 2824000.0, 2828000.0, 2838000.0, 2849000.0, 2859000.0, 2869000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, + 2930000.0, 2950000.0, 2970000.0, 2990000.0, 3010000.0, 3031000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3153000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2716000.0, 2718000.0, + 2720000.0, 2723000.0, 2727000.0, 2731000.0, 2736000.0, 2740000.0, 2744000.0, 2748000.0, 2753000.0, 2757000.0, 2761000.0, 2765000.0, + 2770000.0, 2774000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2807000.0, 2811000.0, 2815000.0, + 2819000.0, 2824000.0, 2828000.0, 2838000.0, 2848000.0, 2858000.0, 2868000.0, 2879000.0, 2889000.0, 2899000.0, 2909000.0, 2919000.0, + 2929000.0, 2949000.0, 2970000.0, 2990000.0, 3010000.0, 3030000.0, 3051000.0, 3071000.0, 3091000.0, 3112000.0, 3132000.0, 3152000.0, + 3173000.0, 3194000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2717000.0, + 2720000.0, 2722000.0, 2726000.0, 2731000.0, 2735000.0, 2739000.0, 2744000.0, 2748000.0, 2752000.0, 2756000.0, 2761000.0, 2765000.0, + 2769000.0, 2773000.0, 2777000.0, 2782000.0, 2786000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2807000.0, 2811000.0, 2815000.0, + 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2848000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2899000.0, 2909000.0, 2919000.0, + 2929000.0, 2949000.0, 2969000.0, 2990000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2719000.0, 2721000.0, 2725000.0, 2730000.0, 2734000.0, 2738000.0, 2743000.0, 2747000.0, 2751000.0, 2756000.0, 2760000.0, 2764000.0, + 2768000.0, 2773000.0, 2777000.0, 2781000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2810000.0, 2814000.0, + 2819000.0, 2823000.0, 2827000.0, 2837000.0, 2847000.0, 2858000.0, 2868000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2919000.0, + 2929000.0, 2949000.0, 2969000.0, 2989000.0, 3010000.0, 3030000.0, 3050000.0, 3071000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2720000.0, 2725000.0, 2729000.0, 2733000.0, 2738000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, 2764000.0, + 2768000.0, 2772000.0, 2776000.0, 2781000.0, 2785000.0, 2789000.0, 2793000.0, 2797000.0, 2801000.0, 2806000.0, 2810000.0, 2814000.0, + 2818000.0, 2822000.0, 2826000.0, 2837000.0, 2847000.0, 2857000.0, 2867000.0, 2878000.0, 2888000.0, 2898000.0, 2908000.0, 2918000.0, + 2928000.0, 2949000.0, 2969000.0, 2989000.0, 3009000.0, 3030000.0, 3050000.0, 3070000.0, 3091000.0, 3111000.0, 3132000.0, 3152000.0, + 3173000.0, 3193000.0, 3214000.0, 3280000.0, 3381000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2723000.0, 2727000.0, 2732000.0, 2736000.0, 2741000.0, 2745000.0, 2749000.0, 2754000.0, 2758000.0, 2762000.0, + 2767000.0, 2771000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2796000.0, 2800000.0, 2805000.0, 2809000.0, 2813000.0, + 2817000.0, 2821000.0, 2825000.0, 2836000.0, 2846000.0, 2856000.0, 2867000.0, 2877000.0, 2887000.0, 2897000.0, 2907000.0, 2918000.0, + 2928000.0, 2948000.0, 2968000.0, 2989000.0, 3009000.0, 3029000.0, 3050000.0, 3070000.0, 3090000.0, 3111000.0, 3131000.0, 3152000.0, + 3172000.0, 3193000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2726000.0, 2730000.0, 2735000.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, 2757000.0, 2761000.0, + 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2799000.0, 2803000.0, 2808000.0, 2812000.0, + 2816000.0, 2820000.0, 2824000.0, 2835000.0, 2845000.0, 2855000.0, 2866000.0, 2876000.0, 2886000.0, 2896000.0, 2907000.0, 2917000.0, + 2927000.0, 2947000.0, 2968000.0, 2988000.0, 3008000.0, 3029000.0, 3049000.0, 3069000.0, 3090000.0, 3110000.0, 3131000.0, 3151000.0, + 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3487000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2728000.0, 2733000.0, 2737000.0, 2742000.0, 2746000.0, 2751000.0, 2755000.0, 2759000.0, + 2764000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2802000.0, 2806000.0, 2811000.0, + 2815000.0, 2819000.0, 2823000.0, 2834000.0, 2844000.0, 2854000.0, 2865000.0, 2875000.0, 2885000.0, 2896000.0, 2906000.0, 2916000.0, + 2926000.0, 2947000.0, 2967000.0, 2987000.0, 3008000.0, 3028000.0, 3049000.0, 3069000.0, 3089000.0, 3110000.0, 3130000.0, 3151000.0, + 3172000.0, 3192000.0, 3213000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2731000.0, 2735000.0, 2740000.0, 2744000.0, 2749000.0, 2753000.0, 2758000.0, + 2762000.0, 2767000.0, 2771000.0, 2775000.0, 2780000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, 2809000.0, + 2814000.0, 2818000.0, 2822000.0, 2833000.0, 2843000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2895000.0, 2905000.0, 2915000.0, + 2926000.0, 2946000.0, 2966000.0, 2987000.0, 3007000.0, 3028000.0, 3048000.0, 3069000.0, 3089000.0, 3109000.0, 3130000.0, 3151000.0, + 3171000.0, 3192000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2733000.0, 2738000.0, 2743000.0, 2747000.0, 2752000.0, 2756000.0, + 2761000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2782000.0, 2787000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, 2808000.0, + 2812000.0, 2817000.0, 2821000.0, 2831000.0, 2842000.0, 2852000.0, 2863000.0, 2873000.0, 2884000.0, 2894000.0, 2904000.0, 2915000.0, + 2925000.0, 2945000.0, 2966000.0, 2986000.0, 3007000.0, 3027000.0, 3048000.0, 3068000.0, 3089000.0, 3109000.0, 3130000.0, 3150000.0, + 3171000.0, 3191000.0, 3212000.0, 3280000.0, 3380000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2736000.0, 2741000.0, 2745000.0, 2750000.0, 2754000.0, + 2759000.0, 2763000.0, 2768000.0, 2772000.0, 2777000.0, 2781000.0, 2785000.0, 2790000.0, 2794000.0, 2798000.0, 2803000.0, 2807000.0, + 2811000.0, 2815000.0, 2820000.0, 2830000.0, 2841000.0, 2851000.0, 2862000.0, 2872000.0, 2883000.0, 2893000.0, 2903000.0, 2914000.0, + 2924000.0, 2945000.0, 2965000.0, 2986000.0, 3006000.0, 3027000.0, 3047000.0, 3068000.0, 3088000.0, 3109000.0, 3129000.0, 3150000.0, + 3170000.0, 3191000.0, 3212000.0, 3280000.0, 3379000.0, 3486000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2739000.0, 2743000.0, 2748000.0, 2752000.0, + 2757000.0, 2761000.0, 2766000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2788000.0, 2792000.0, 2797000.0, 2801000.0, 2805000.0, + 2810000.0, 2814000.0, 2818000.0, 2829000.0, 2840000.0, 2850000.0, 2861000.0, 2871000.0, 2882000.0, 2892000.0, 2902000.0, 2913000.0, + 2923000.0, 2944000.0, 2964000.0, 2985000.0, 3005000.0, 3026000.0, 3046000.0, 3067000.0, 3088000.0, 3108000.0, 3129000.0, 3149000.0, + 3170000.0, 3191000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2741000.0, 2746000.0, 2750000.0, + 2755000.0, 2760000.0, 2764000.0, 2769000.0, 2773000.0, 2778000.0, 2782000.0, 2786000.0, 2791000.0, 2795000.0, 2800000.0, 2804000.0, + 2808000.0, 2813000.0, 2817000.0, 2828000.0, 2838000.0, 2849000.0, 2860000.0, 2870000.0, 2881000.0, 2891000.0, 2901000.0, 2912000.0, + 2922000.0, 2943000.0, 2964000.0, 2984000.0, 3005000.0, 3025000.0, 3046000.0, 3066000.0, 3087000.0, 3108000.0, 3128000.0, 3149000.0, + 3170000.0, 3190000.0, 3211000.0, 3280000.0, 3379000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2744000.0, 2748000.0, + 2753000.0, 2758000.0, 2762000.0, 2767000.0, 2771000.0, 2776000.0, 2780000.0, 2785000.0, 2789000.0, 2794000.0, 2798000.0, 2802000.0, + 2807000.0, 2811000.0, 2815000.0, 2826000.0, 2837000.0, 2848000.0, 2858000.0, 2869000.0, 2879000.0, 2890000.0, 2900000.0, 2911000.0, + 2921000.0, 2942000.0, 2963000.0, 2983000.0, 3004000.0, 3025000.0, 3045000.0, 3066000.0, 3086000.0, 3107000.0, 3128000.0, 3148000.0, + 3169000.0, 3190000.0, 3211000.0, 3280000.0, 3378000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2746000.0, + 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2769000.0, 2774000.0, 2778000.0, 2783000.0, 2787000.0, 2792000.0, 2796000.0, 2801000.0, + 2805000.0, 2810000.0, 2814000.0, 2825000.0, 2836000.0, 2846000.0, 2857000.0, 2868000.0, 2878000.0, 2889000.0, 2899000.0, 2910000.0, + 2920000.0, 2941000.0, 2962000.0, 2983000.0, 3003000.0, 3024000.0, 3045000.0, 3065000.0, 3086000.0, 3106000.0, 3127000.0, 3148000.0, + 3169000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3485000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2748000.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2776000.0, 2781000.0, 2786000.0, 2790000.0, 2795000.0, 2799000.0, + 2803000.0, 2808000.0, 2812000.0, 2823000.0, 2834000.0, 2845000.0, 2856000.0, 2866000.0, 2877000.0, 2888000.0, 2898000.0, 2909000.0, + 2919000.0, 2940000.0, 2961000.0, 2982000.0, 3002000.0, 3023000.0, 3044000.0, 3064000.0, 3085000.0, 3106000.0, 3127000.0, 3147000.0, + 3168000.0, 3189000.0, 3210000.0, 3280000.0, 3378000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2751000.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2788000.0, 2793000.0, 2797000.0, + 2802000.0, 2806000.0, 2811000.0, 2822000.0, 2833000.0, 2843000.0, 2854000.0, 2865000.0, 2876000.0, 2886000.0, 2897000.0, 2908000.0, + 2918000.0, 2939000.0, 2960000.0, 2981000.0, 3002000.0, 3022000.0, 3043000.0, 3064000.0, 3085000.0, 3105000.0, 3126000.0, 3147000.0, + 3168000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2753000.0, 2758000.0, 2763000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, 2791000.0, 2795000.0, + 2800000.0, 2804000.0, 2809000.0, 2820000.0, 2831000.0, 2842000.0, 2853000.0, 2864000.0, 2874000.0, 2885000.0, 2896000.0, 2906000.0, + 2917000.0, 2938000.0, 2959000.0, 2980000.0, 3001000.0, 3022000.0, 3042000.0, 3063000.0, 3084000.0, 3105000.0, 3125000.0, 3146000.0, + 3167000.0, 3188000.0, 3209000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2755000.0, 2760000.0, 2765000.0, 2770000.0, 2775000.0, 2779000.0, 2784000.0, 2789000.0, 2793000.0, + 2798000.0, 2802000.0, 2807000.0, 2818000.0, 2829000.0, 2840000.0, 2851000.0, 2862000.0, 2873000.0, 2884000.0, 2894000.0, 2905000.0, + 2916000.0, 2937000.0, 2958000.0, 2979000.0, 3000000.0, 3021000.0, 3042000.0, 3062000.0, 3083000.0, 3104000.0, 3125000.0, 3146000.0, + 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3377000.0, 3484000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2757000.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2782000.0, 2786000.0, 2791000.0, + 2796000.0, 2800000.0, 2805000.0, 2816000.0, 2827000.0, 2839000.0, 2850000.0, 2861000.0, 2872000.0, 2882000.0, 2893000.0, 2904000.0, + 2915000.0, 2936000.0, 2957000.0, 2978000.0, 2999000.0, 3020000.0, 3041000.0, 3062000.0, 3082000.0, 3103000.0, 3124000.0, 3145000.0, + 3166000.0, 3187000.0, 3208000.0, 3280000.0, 3376000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2760000.0, 2765000.0, 2770000.0, 2774000.0, 2779000.0, 2784000.0, 2789000.0, + 2793000.0, 2798000.0, 2803000.0, 2814000.0, 2826000.0, 2837000.0, 2848000.0, 2859000.0, 2870000.0, 2881000.0, 2892000.0, 2902000.0, + 2913000.0, 2935000.0, 2956000.0, 2977000.0, 2998000.0, 3019000.0, 3040000.0, 3061000.0, 3082000.0, 3102000.0, 3123000.0, 3144000.0, + 3165000.0, 3186000.0, 3207000.0, 3280000.0, 3376000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2762000.0, 2767000.0, 2772000.0, 2777000.0, 2781000.0, 2786000.0, + 2791000.0, 2796000.0, 2800000.0, 2812000.0, 2824000.0, 2835000.0, 2846000.0, 2857000.0, 2868000.0, 2879000.0, 2890000.0, 2901000.0, + 2912000.0, 2933000.0, 2955000.0, 2976000.0, 2997000.0, 3018000.0, 3039000.0, 3060000.0, 3081000.0, 3102000.0, 3123000.0, 3144000.0, + 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3483000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2764000.0, 2769000.0, 2774000.0, 2779000.0, 2784000.0, + 2789000.0, 2793000.0, 2798000.0, 2810000.0, 2821000.0, 2833000.0, 2844000.0, 2855000.0, 2867000.0, 2878000.0, 2889000.0, 2900000.0, + 2910000.0, 2932000.0, 2953000.0, 2975000.0, 2996000.0, 3017000.0, 3038000.0, 3059000.0, 3080000.0, 3101000.0, 3122000.0, 3143000.0, + 3164000.0, 3185000.0, 3206000.0, 3280000.0, 3375000.0, 3482000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2766000.0, 2771000.0, 2776000.0, 2781000.0, + 2786000.0, 2791000.0, 2796000.0, 2808000.0, 2819000.0, 2831000.0, 2842000.0, 2854000.0, 2865000.0, 2876000.0, 2887000.0, 2898000.0, + 2909000.0, 2931000.0, 2952000.0, 2973000.0, 2995000.0, 3016000.0, 3037000.0, 3058000.0, 3079000.0, 3100000.0, 3121000.0, 3142000.0, + 3163000.0, 3184000.0, 3205000.0, 3280000.0, 3374000.0, 3482000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2768000.0, 2773000.0, 2778000.0, + 2783000.0, 2788000.0, 2793000.0, 2805000.0, 2817000.0, 2829000.0, 2840000.0, 2852000.0, 2863000.0, 2874000.0, 2885000.0, 2896000.0, + 2907000.0, 2929000.0, 2951000.0, 2972000.0, 2994000.0, 3015000.0, 3036000.0, 3057000.0, 3078000.0, 3099000.0, 3120000.0, 3141000.0, + 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3374000.0, 3481000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2770000.0, 2775000.0, + 2780000.0, 2785000.0, 2790000.0, 2802000.0, 2814000.0, 2826000.0, 2838000.0, 2850000.0, 2861000.0, 2872000.0, 2883000.0, 2895000.0, + 2906000.0, 2928000.0, 2949000.0, 2971000.0, 2992000.0, 3014000.0, 3035000.0, 3056000.0, 3077000.0, 3098000.0, 3119000.0, 3140000.0, + 3162000.0, 3183000.0, 3204000.0, 3280000.0, 3373000.0, 3481000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2772000.0, + 2777000.0, 2782000.0, 2787000.0, 2800000.0, 2812000.0, 2824000.0, 2836000.0, 2847000.0, 2859000.0, 2870000.0, 2882000.0, 2893000.0, + 2904000.0, 2926000.0, 2948000.0, 2969000.0, 2991000.0, 3012000.0, 3034000.0, 3055000.0, 3076000.0, 3097000.0, 3118000.0, 3140000.0, + 3161000.0, 3182000.0, 3203000.0, 3280000.0, 3373000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2774000.0, 2779000.0, 2784000.0, 2797000.0, 2809000.0, 2821000.0, 2833000.0, 2845000.0, 2857000.0, 2868000.0, 2880000.0, 2891000.0, + 2902000.0, 2924000.0, 2946000.0, 2968000.0, 2990000.0, 3011000.0, 3033000.0, 3054000.0, 3075000.0, 3096000.0, 3118000.0, 3139000.0, + 3160000.0, 3181000.0, 3202000.0, 3280000.0, 3372000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2775000.0, 2781000.0, 2794000.0, 2806000.0, 2819000.0, 2831000.0, 2843000.0, 2854000.0, 2866000.0, 2878000.0, 2889000.0, + 2900000.0, 2923000.0, 2945000.0, 2967000.0, 2988000.0, 3010000.0, 3031000.0, 3053000.0, 3074000.0, 3095000.0, 3117000.0, 3138000.0, + 3159000.0, 3180000.0, 3201000.0, 3280000.0, 3372000.0, 3480000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2777000.0, 2790000.0, 2803000.0, 2816000.0, 2828000.0, 2840000.0, 2852000.0, 2864000.0, 2875000.0, 2887000.0, + 2898000.0, 2921000.0, 2943000.0, 2965000.0, 2987000.0, 3009000.0, 3030000.0, 3052000.0, 3073000.0, 3094000.0, 3116000.0, 3137000.0, + 3158000.0, 3179000.0, 3201000.0, 3280000.0, 3371000.0, 3479000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2781000.0, 2795000.0, 2808000.0, 2821000.0, 2833000.0, 2846000.0, 2858000.0, 2870000.0, 2881000.0, + 2893000.0, 2916000.0, 2939000.0, 2961000.0, 2983000.0, 3005000.0, 3027000.0, 3048000.0, 3070000.0, 3091000.0, 3113000.0, 3134000.0, + 3156000.0, 3177000.0, 3198000.0, 3280000.0, 3370000.0, 3478000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2785000.0, 2799000.0, 2813000.0, 2826000.0, 2838000.0, 2851000.0, 2863000.0, 2875000.0, + 2887000.0, 2910000.0, 2933000.0, 2956000.0, 2979000.0, 3001000.0, 3023000.0, 3045000.0, 3067000.0, 3088000.0, 3110000.0, 3132000.0, + 3153000.0, 3175000.0, 3196000.0, 3280000.0, 3368000.0, 3476000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2789000.0, 2803000.0, 2817000.0, 2830000.0, 2843000.0, 2856000.0, 2868000.0, + 2880000.0, 2904000.0, 2928000.0, 2951000.0, 2974000.0, 2996000.0, 3019000.0, 3041000.0, 3063000.0, 3085000.0, 3107000.0, 3128000.0, + 3150000.0, 3172000.0, 3193000.0, 3280000.0, 3366000.0, 3475000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2792000.0, 2807000.0, 2821000.0, 2834000.0, 2847000.0, 2860000.0, + 2873000.0, 2898000.0, 2922000.0, 2945000.0, 2969000.0, 2992000.0, 3014000.0, 3037000.0, 3059000.0, 3081000.0, 3103000.0, 3125000.0, + 3147000.0, 3169000.0, 3190000.0, 3280000.0, 3364000.0, 3473000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2795000.0, 2810000.0, 2824000.0, 2838000.0, 2851000.0, + 2864000.0, 2890000.0, 2915000.0, 2939000.0, 2963000.0, 2986000.0, 3009000.0, 3032000.0, 3055000.0, 3077000.0, 3099000.0, 3121000.0, + 3143000.0, 3165000.0, 3187000.0, 3280000.0, 3362000.0, 3471000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2797000.0, 2813000.0, 2827000.0, 2841000.0, + 2855000.0, 2882000.0, 2907000.0, 2932000.0, 2956000.0, 2980000.0, 3004000.0, 3027000.0, 3050000.0, 3072000.0, 3095000.0, 3117000.0, + 3140000.0, 3162000.0, 3184000.0, 3280000.0, 3359000.0, 3469000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2799000.0, 2815000.0, 2830000.0, + 2844000.0, 2872000.0, 2899000.0, 2924000.0, 2949000.0, 2974000.0, 2998000.0, 3021000.0, 3044000.0, 3067000.0, 3090000.0, 3113000.0, + 3135000.0, 3158000.0, 3180000.0, 3280000.0, 3357000.0, 3467000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2801000.0, 2817000.0, + 2832000.0, 2862000.0, 2889000.0, 2916000.0, 2941000.0, 2966000.0, 2991000.0, 3015000.0, 3039000.0, 3062000.0, 3085000.0, 3108000.0, + 3131000.0, 3154000.0, 3176000.0, 3280000.0, 3354000.0, 3465000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2802000.0, + 2819000.0, 2850000.0, 2879000.0, 2906000.0, 2933000.0, 2958000.0, 2984000.0, 3008000.0, 3032000.0, 3056000.0, 3080000.0, 3103000.0, + 3126000.0, 3149000.0, 3172000.0, 3280000.0, 3351000.0, 3462000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2803000.0, 2836000.0, 2867000.0, 2895000.0, 2923000.0, 2950000.0, 2975000.0, 3001000.0, 3025000.0, 3050000.0, 3073000.0, 3097000.0, + 3121000.0, 3144000.0, 3167000.0, 3280000.0, 3348000.0, 3459000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2803000.0, 2838000.0, 2870000.0, 2900000.0, 2929000.0, 2957000.0, 2983000.0, 3009000.0, 3035000.0, 3060000.0, 3084000.0, + 3108000.0, 3132000.0, 3156000.0, 3280000.0, 3340000.0, 3453000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2801000.0, 2838000.0, 2872000.0, 2904000.0, 2934000.0, 2963000.0, 2990000.0, 3017000.0, 3043000.0, 3069000.0, + 3094000.0, 3119000.0, 3143000.0, 3280000.0, 3332000.0, 3446000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2797000.0, 2837000.0, 2873000.0, 2906000.0, 2937000.0, 2967000.0, 2996000.0, 3023000.0, 3050000.0, + 3077000.0, 3103000.0, 3128000.0, 3280000.0, 3322000.0, 3438000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2790000.0, 2833000.0, 2871000.0, 2906000.0, 2939000.0, 2970000.0, 3000000.0, 3029000.0, + 3057000.0, 3084000.0, 3110000.0, 3280000.0, 3310000.0, 3429000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2780000.0, 2826000.0, 2867000.0, 2905000.0, 2939000.0, 2972000.0, 3003000.0, + 3033000.0, 3062000.0, 3090000.0, 3280000.0, 3297000.0, 3418000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2767000.0, 2817000.0, + 2861000.0, 2901000.0, 2938000.0, 2972000.0, 3004000.0, 3036000.0, 3066000.0, 3280000.0, 3282000.0, 3406000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2750000.0, + 2806000.0, 2853000.0, 2895000.0, 2934000.0, 2970000.0, 3004000.0, 3037000.0, 3280000.0, 3264000.0, 3392000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2728000.0, + 2790000.0, 2842000.0, 2887000.0, 2929000.0, 2967000.0, 3003000.0, 3280000.0, 3244000.0, 3377000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 2701000.0, 2771000.0, 2828000.0, 2877000.0, 2921000.0, 2961000.0, 3280000.0, 3222000.0, 3359000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2666000.0, 2747000.0, 2810000.0, 2864000.0, 2911000.0, 3280000.0, 3195000.0, 3339000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2622000.0, 2718000.0, 2789000.0, 2847000.0, 3280000.0, 3165000.0, 3316000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2564000.0, 2683000.0, 2763000.0, 3280000.0, 3130000.0, 3290000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2481000.0, 2641000.0, 3280000.0, 3089000.0, 3260000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2335000.0, 3280000.0, 3040000.0, 3226000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2821000.0, 3085000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2671000.0, 2998000.0}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3280000.0, 2512000.0, 2906000.0}}}; + static constexpr std::array, DefaultNumSteamSuperheatedPressure> - DefaultSteamSuperheatedDensityDataTable = { - {{4.855e-03, 4.837e-03, 4.767e-03, 4.683e-03, 4.601e-03, 4.522e-03, 4.446e-03, 4.373e-03, 4.302e-03, 4.233e-03, 4.167e-03, 4.102e-03, - 4.039e-03, 3.979e-03, 3.920e-03, 3.863e-03, 3.840e-03, 3.818e-03, 3.796e-03, 3.775e-03, 3.753e-03, 3.732e-03, 3.711e-03, 3.691e-03, - 3.670e-03, 3.650e-03, 3.630e-03, 3.610e-03, 3.591e-03, 3.571e-03, 3.562e-03, 3.552e-03, 3.543e-03, 3.533e-03, 3.524e-03, 3.514e-03, - 3.505e-03, 3.496e-03, 3.487e-03, 3.477e-03, 3.468e-03, 3.459e-03, 3.450e-03, 3.441e-03, 3.432e-03, 3.424e-03, 3.415e-03, 3.406e-03, - 3.397e-03, 3.388e-03, 3.380e-03, 3.371e-03, 3.363e-03, 3.354e-03, 3.346e-03, 3.337e-03, 3.329e-03, 3.321e-03, 3.312e-03, 3.304e-03, - 3.296e-03, 3.288e-03, 3.271e-03, 3.255e-03, 3.239e-03, 3.224e-03, 3.208e-03, 3.193e-03, 3.177e-03, 3.162e-03, 3.147e-03, 3.132e-03, - 3.117e-03, 3.103e-03, 3.088e-03, 3.074e-03, 3.060e-03, 3.046e-03, 3.032e-03, 3.018e-03, 3.004e-03, 2.991e-03, 2.977e-03, 2.964e-03, - 2.951e-03, 2.938e-03, 2.925e-03, 2.893e-03, 2.862e-03, 2.831e-03, 2.801e-03, 2.772e-03, 2.743e-03, 2.715e-03, 2.688e-03, 2.661e-03, - 2.634e-03, 2.583e-03, 2.533e-03, 2.486e-03, 2.440e-03, 2.396e-03, 2.353e-03, 2.312e-03, 2.273e-03, 2.234e-03, 2.197e-03, 2.162e-03, - 2.127e-03, 2.093e-03, 2.061e-03, 3.542e-05, 1.833e-03, 1.714e-03}, - {0.0, 5.196e-03, 5.121e-03, 5.031e-03, 4.943e-03, 4.859e-03, 4.777e-03, 4.698e-03, 4.622e-03, 4.548e-03, 4.476e-03, 4.407e-03, - 4.340e-03, 4.274e-03, 4.211e-03, 4.150e-03, 4.126e-03, 4.102e-03, 4.078e-03, 4.055e-03, 4.032e-03, 4.009e-03, 3.987e-03, 3.965e-03, - 3.943e-03, 3.921e-03, 3.899e-03, 3.878e-03, 3.857e-03, 3.836e-03, 3.826e-03, 3.816e-03, 3.806e-03, 3.795e-03, 3.785e-03, 3.775e-03, - 3.765e-03, 3.755e-03, 3.746e-03, 3.736e-03, 3.726e-03, 3.716e-03, 3.707e-03, 3.697e-03, 3.687e-03, 3.678e-03, 3.668e-03, 3.659e-03, - 3.650e-03, 3.640e-03, 3.631e-03, 3.622e-03, 3.612e-03, 3.603e-03, 3.594e-03, 3.585e-03, 3.576e-03, 3.567e-03, 3.558e-03, 3.549e-03, - 3.541e-03, 3.532e-03, 3.514e-03, 3.497e-03, 3.480e-03, 3.463e-03, 3.446e-03, 3.430e-03, 3.413e-03, 3.397e-03, 3.381e-03, 3.365e-03, - 3.349e-03, 3.333e-03, 3.318e-03, 3.302e-03, 3.287e-03, 3.272e-03, 3.257e-03, 3.242e-03, 3.228e-03, 3.213e-03, 3.198e-03, 3.184e-03, - 3.170e-03, 3.156e-03, 3.142e-03, 3.108e-03, 3.074e-03, 3.041e-03, 3.009e-03, 2.978e-03, 2.947e-03, 2.917e-03, 2.887e-03, 2.858e-03, - 2.830e-03, 2.775e-03, 2.722e-03, 2.671e-03, 2.621e-03, 2.574e-03, 2.528e-03, 2.484e-03, 2.442e-03, 2.400e-03, 2.361e-03, 2.322e-03, - 2.285e-03, 2.249e-03, 2.214e-03, 3.542e-05, 1.969e-03, 1.841e-03}, - {0.0, 0.0, 6.802e-03, 6.681e-03, 6.565e-03, 6.453e-03, 6.344e-03, 6.239e-03, 6.138e-03, 6.040e-03, 5.944e-03, 5.852e-03, - 5.763e-03, 5.676e-03, 5.592e-03, 5.511e-03, 5.479e-03, 5.447e-03, 5.416e-03, 5.385e-03, 5.355e-03, 5.324e-03, 5.295e-03, 5.265e-03, - 5.236e-03, 5.207e-03, 5.178e-03, 5.150e-03, 5.122e-03, 5.095e-03, 5.081e-03, 5.067e-03, 5.054e-03, 5.040e-03, 5.027e-03, 5.014e-03, - 5.000e-03, 4.987e-03, 4.974e-03, 4.961e-03, 4.948e-03, 4.935e-03, 4.922e-03, 4.909e-03, 4.897e-03, 4.884e-03, 4.871e-03, 4.859e-03, - 4.846e-03, 4.834e-03, 4.822e-03, 4.809e-03, 4.797e-03, 4.785e-03, 4.773e-03, 4.761e-03, 4.749e-03, 4.737e-03, 4.725e-03, 4.714e-03, - 4.702e-03, 4.690e-03, 4.667e-03, 4.644e-03, 4.621e-03, 4.599e-03, 4.577e-03, 4.555e-03, 4.533e-03, 4.511e-03, 4.490e-03, 4.468e-03, - 4.447e-03, 4.427e-03, 4.406e-03, 4.385e-03, 4.365e-03, 4.345e-03, 4.325e-03, 4.306e-03, 4.286e-03, 4.267e-03, 4.247e-03, 4.228e-03, - 4.210e-03, 4.191e-03, 4.172e-03, 4.127e-03, 4.082e-03, 4.039e-03, 3.996e-03, 3.954e-03, 3.913e-03, 3.873e-03, 3.834e-03, 3.796e-03, - 3.758e-03, 3.685e-03, 3.614e-03, 3.546e-03, 3.481e-03, 3.418e-03, 3.357e-03, 3.299e-03, 3.242e-03, 3.188e-03, 3.135e-03, 3.084e-03, - 3.034e-03, 2.986e-03, 2.940e-03, 3.542e-05, 2.615e-03, 2.445e-03}, - {0.0, 0.0, 0.0, 9.407e-03, 9.243e-03, 9.084e-03, 8.931e-03, 8.783e-03, 8.640e-03, 8.502e-03, 8.368e-03, 8.238e-03, - 8.113e-03, 7.991e-03, 7.872e-03, 7.757e-03, 7.712e-03, 7.668e-03, 7.624e-03, 7.580e-03, 7.537e-03, 7.495e-03, 7.453e-03, 7.411e-03, - 7.370e-03, 7.330e-03, 7.289e-03, 7.250e-03, 7.210e-03, 7.172e-03, 7.152e-03, 7.133e-03, 7.114e-03, 7.095e-03, 7.076e-03, 7.057e-03, - 7.039e-03, 7.020e-03, 7.002e-03, 6.983e-03, 6.965e-03, 6.947e-03, 6.929e-03, 6.911e-03, 6.893e-03, 6.875e-03, 6.857e-03, 6.840e-03, - 6.822e-03, 6.805e-03, 6.787e-03, 6.770e-03, 6.753e-03, 6.736e-03, 6.719e-03, 6.702e-03, 6.685e-03, 6.668e-03, 6.651e-03, 6.635e-03, - 6.618e-03, 6.602e-03, 6.569e-03, 6.537e-03, 6.505e-03, 6.473e-03, 6.442e-03, 6.411e-03, 6.380e-03, 6.350e-03, 6.320e-03, 6.290e-03, - 6.260e-03, 6.231e-03, 6.202e-03, 6.173e-03, 6.144e-03, 6.116e-03, 6.088e-03, 6.060e-03, 6.033e-03, 6.006e-03, 5.979e-03, 5.952e-03, - 5.925e-03, 5.899e-03, 5.873e-03, 5.809e-03, 5.746e-03, 5.685e-03, 5.625e-03, 5.566e-03, 5.508e-03, 5.452e-03, 5.397e-03, 5.342e-03, - 5.289e-03, 5.186e-03, 5.087e-03, 4.992e-03, 4.900e-03, 4.811e-03, 4.726e-03, 4.643e-03, 4.564e-03, 4.487e-03, 4.412e-03, 4.340e-03, - 4.271e-03, 4.203e-03, 4.138e-03, 3.542e-05, 3.680e-03, 3.442e-03}, - {0.0, 0.0, 0.0, 0.0, 1.284e-02, 1.262e-02, 1.241e-02, 1.220e-02, 1.200e-02, 1.181e-02, 1.162e-02, 1.144e-02, - 1.127e-02, 1.110e-02, 1.093e-02, 1.078e-02, 1.071e-02, 1.065e-02, 1.059e-02, 1.053e-02, 1.047e-02, 1.041e-02, 1.035e-02, 1.029e-02, - 1.024e-02, 1.018e-02, 1.012e-02, 1.007e-02, 1.001e-02, 9.961e-03, 9.934e-03, 9.907e-03, 9.881e-03, 9.855e-03, 9.828e-03, 9.802e-03, - 9.776e-03, 9.750e-03, 9.725e-03, 9.699e-03, 9.674e-03, 9.649e-03, 9.623e-03, 9.598e-03, 9.574e-03, 9.549e-03, 9.524e-03, 9.500e-03, - 9.475e-03, 9.451e-03, 9.427e-03, 9.403e-03, 9.379e-03, 9.355e-03, 9.332e-03, 9.308e-03, 9.285e-03, 9.261e-03, 9.238e-03, 9.215e-03, - 9.192e-03, 9.170e-03, 9.124e-03, 9.079e-03, 9.035e-03, 8.991e-03, 8.947e-03, 8.904e-03, 8.862e-03, 8.819e-03, 8.777e-03, 8.736e-03, - 8.695e-03, 8.654e-03, 8.614e-03, 8.574e-03, 8.534e-03, 8.495e-03, 8.456e-03, 8.417e-03, 8.379e-03, 8.341e-03, 8.304e-03, 8.267e-03, - 8.230e-03, 8.193e-03, 8.157e-03, 8.068e-03, 7.981e-03, 7.896e-03, 7.812e-03, 7.731e-03, 7.651e-03, 7.572e-03, 7.495e-03, 7.420e-03, - 7.346e-03, 7.203e-03, 7.065e-03, 6.933e-03, 6.805e-03, 6.682e-03, 6.563e-03, 6.449e-03, 6.338e-03, 6.231e-03, 6.128e-03, 6.028e-03, - 5.931e-03, 5.838e-03, 5.747e-03, 3.542e-05, 5.111e-03, 4.781e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 1.731e-02, 1.702e-02, 1.674e-02, 1.646e-02, 1.620e-02, 1.594e-02, 1.570e-02, - 1.546e-02, 1.522e-02, 1.500e-02, 1.478e-02, 1.469e-02, 1.461e-02, 1.452e-02, 1.444e-02, 1.436e-02, 1.428e-02, 1.420e-02, 1.412e-02, - 1.404e-02, 1.396e-02, 1.389e-02, 1.381e-02, 1.374e-02, 1.366e-02, 1.362e-02, 1.359e-02, 1.355e-02, 1.352e-02, 1.348e-02, 1.344e-02, - 1.341e-02, 1.337e-02, 1.334e-02, 1.330e-02, 1.327e-02, 1.323e-02, 1.320e-02, 1.316e-02, 1.313e-02, 1.310e-02, 1.306e-02, 1.303e-02, - 1.300e-02, 1.296e-02, 1.293e-02, 1.290e-02, 1.286e-02, 1.283e-02, 1.280e-02, 1.277e-02, 1.273e-02, 1.270e-02, 1.267e-02, 1.264e-02, - 1.261e-02, 1.258e-02, 1.251e-02, 1.245e-02, 1.239e-02, 1.233e-02, 1.227e-02, 1.221e-02, 1.215e-02, 1.210e-02, 1.204e-02, 1.198e-02, - 1.192e-02, 1.187e-02, 1.181e-02, 1.176e-02, 1.170e-02, 1.165e-02, 1.160e-02, 1.154e-02, 1.149e-02, 1.144e-02, 1.139e-02, 1.134e-02, - 1.129e-02, 1.124e-02, 1.119e-02, 1.107e-02, 1.095e-02, 1.083e-02, 1.071e-02, 1.060e-02, 1.049e-02, 1.038e-02, 1.028e-02, 1.018e-02, - 1.007e-02, 9.879e-03, 9.690e-03, 9.508e-03, 9.333e-03, 9.164e-03, 9.001e-03, 8.844e-03, 8.692e-03, 8.546e-03, 8.404e-03, 8.267e-03, - 8.134e-03, 8.006e-03, 7.881e-03, 3.542e-05, 7.009e-03, 6.556e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.307e-02, 2.269e-02, 2.232e-02, 2.196e-02, 2.161e-02, 2.128e-02, - 2.095e-02, 2.063e-02, 2.033e-02, 2.003e-02, 1.991e-02, 1.980e-02, 1.968e-02, 1.957e-02, 1.946e-02, 1.935e-02, 1.924e-02, 1.913e-02, - 1.903e-02, 1.892e-02, 1.882e-02, 1.872e-02, 1.862e-02, 1.851e-02, 1.846e-02, 1.842e-02, 1.837e-02, 1.832e-02, 1.827e-02, 1.822e-02, - 1.817e-02, 1.812e-02, 1.808e-02, 1.803e-02, 1.798e-02, 1.793e-02, 1.789e-02, 1.784e-02, 1.779e-02, 1.775e-02, 1.770e-02, 1.766e-02, - 1.761e-02, 1.757e-02, 1.752e-02, 1.748e-02, 1.743e-02, 1.739e-02, 1.734e-02, 1.730e-02, 1.726e-02, 1.721e-02, 1.717e-02, 1.713e-02, - 1.708e-02, 1.704e-02, 1.696e-02, 1.687e-02, 1.679e-02, 1.671e-02, 1.663e-02, 1.655e-02, 1.647e-02, 1.639e-02, 1.631e-02, 1.624e-02, - 1.616e-02, 1.608e-02, 1.601e-02, 1.593e-02, 1.586e-02, 1.579e-02, 1.572e-02, 1.564e-02, 1.557e-02, 1.550e-02, 1.543e-02, 1.536e-02, - 1.530e-02, 1.523e-02, 1.516e-02, 1.499e-02, 1.483e-02, 1.467e-02, 1.452e-02, 1.437e-02, 1.422e-02, 1.407e-02, 1.393e-02, 1.379e-02, - 1.365e-02, 1.339e-02, 1.313e-02, 1.288e-02, 1.265e-02, 1.242e-02, 1.220e-02, 1.198e-02, 1.178e-02, 1.158e-02, 1.139e-02, 1.120e-02, - 1.102e-02, 1.085e-02, 1.068e-02, 3.542e-05, 9.498e-03, 8.884e-03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.042e-02, 2.992e-02, 2.943e-02, 2.897e-02, 2.851e-02, - 2.808e-02, 2.765e-02, 2.724e-02, 2.684e-02, 2.669e-02, 2.653e-02, 2.638e-02, 2.623e-02, 2.608e-02, 2.593e-02, 2.579e-02, 2.564e-02, - 2.550e-02, 2.536e-02, 2.522e-02, 2.508e-02, 2.494e-02, 2.481e-02, 2.474e-02, 2.468e-02, 2.461e-02, 2.454e-02, 2.448e-02, 2.441e-02, - 2.435e-02, 2.428e-02, 2.422e-02, 2.416e-02, 2.409e-02, 2.403e-02, 2.397e-02, 2.391e-02, 2.384e-02, 2.378e-02, 2.372e-02, 2.366e-02, - 2.360e-02, 2.354e-02, 2.348e-02, 2.342e-02, 2.336e-02, 2.330e-02, 2.324e-02, 2.318e-02, 2.312e-02, 2.306e-02, 2.301e-02, 2.295e-02, - 2.289e-02, 2.284e-02, 2.272e-02, 2.261e-02, 2.250e-02, 2.239e-02, 2.228e-02, 2.217e-02, 2.207e-02, 2.196e-02, 2.186e-02, 2.175e-02, - 2.165e-02, 2.155e-02, 2.145e-02, 2.135e-02, 2.125e-02, 2.115e-02, 2.106e-02, 2.096e-02, 2.087e-02, 2.077e-02, 2.068e-02, 2.059e-02, - 2.049e-02, 2.040e-02, 2.031e-02, 2.009e-02, 1.987e-02, 1.966e-02, 1.945e-02, 1.925e-02, 1.905e-02, 1.885e-02, 1.866e-02, 1.848e-02, - 1.829e-02, 1.794e-02, 1.759e-02, 1.726e-02, 1.694e-02, 1.664e-02, 1.634e-02, 1.606e-02, 1.578e-02, 1.552e-02, 1.526e-02, 1.501e-02, - 1.477e-02, 1.453e-02, 1.431e-02, 3.542e-05, 1.273e-02, 1.190e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.967e-02, 3.903e-02, 3.841e-02, 3.781e-02, - 3.723e-02, 3.666e-02, 3.612e-02, 3.559e-02, 3.538e-02, 3.518e-02, 3.497e-02, 3.477e-02, 3.457e-02, 3.438e-02, 3.419e-02, 3.399e-02, - 3.380e-02, 3.362e-02, 3.343e-02, 3.325e-02, 3.307e-02, 3.289e-02, 3.280e-02, 3.271e-02, 3.262e-02, 3.254e-02, 3.245e-02, 3.236e-02, - 3.228e-02, 3.219e-02, 3.211e-02, 3.202e-02, 3.194e-02, 3.186e-02, 3.177e-02, 3.169e-02, 3.161e-02, 3.153e-02, 3.144e-02, 3.136e-02, - 3.128e-02, 3.120e-02, 3.112e-02, 3.104e-02, 3.096e-02, 3.089e-02, 3.081e-02, 3.073e-02, 3.065e-02, 3.058e-02, 3.050e-02, 3.042e-02, - 3.035e-02, 3.027e-02, 3.012e-02, 2.997e-02, 2.983e-02, 2.968e-02, 2.954e-02, 2.939e-02, 2.925e-02, 2.911e-02, 2.897e-02, 2.884e-02, - 2.870e-02, 2.857e-02, 2.843e-02, 2.830e-02, 2.817e-02, 2.804e-02, 2.791e-02, 2.778e-02, 2.766e-02, 2.753e-02, 2.741e-02, 2.729e-02, - 2.716e-02, 2.704e-02, 2.692e-02, 2.663e-02, 2.634e-02, 2.606e-02, 2.579e-02, 2.552e-02, 2.525e-02, 2.499e-02, 2.474e-02, 2.449e-02, - 2.425e-02, 2.377e-02, 2.332e-02, 2.288e-02, 2.246e-02, 2.205e-02, 2.166e-02, 2.128e-02, 2.092e-02, 2.057e-02, 2.022e-02, 1.989e-02, - 1.957e-02, 1.927e-02, 1.897e-02, 3.542e-05, 1.687e-02, 1.578e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.124e-02, 5.042e-02, 4.963e-02, - 4.887e-02, 4.812e-02, 4.741e-02, 4.671e-02, 4.644e-02, 4.617e-02, 4.590e-02, 4.564e-02, 4.537e-02, 4.512e-02, 4.486e-02, 4.461e-02, - 4.436e-02, 4.412e-02, 4.387e-02, 4.363e-02, 4.340e-02, 4.316e-02, 4.304e-02, 4.293e-02, 4.281e-02, 4.270e-02, 4.258e-02, 4.247e-02, - 4.236e-02, 4.225e-02, 4.213e-02, 4.202e-02, 4.191e-02, 4.180e-02, 4.169e-02, 4.158e-02, 4.148e-02, 4.137e-02, 4.126e-02, 4.116e-02, - 4.105e-02, 4.094e-02, 4.084e-02, 4.073e-02, 4.063e-02, 4.053e-02, 4.043e-02, 4.032e-02, 4.022e-02, 4.012e-02, 4.002e-02, 3.992e-02, - 3.982e-02, 3.972e-02, 3.952e-02, 3.933e-02, 3.914e-02, 3.895e-02, 3.876e-02, 3.857e-02, 3.838e-02, 3.820e-02, 3.802e-02, 3.784e-02, - 3.766e-02, 3.748e-02, 3.731e-02, 3.713e-02, 3.696e-02, 3.679e-02, 3.662e-02, 3.646e-02, 3.629e-02, 3.613e-02, 3.596e-02, 3.580e-02, - 3.564e-02, 3.548e-02, 3.533e-02, 3.494e-02, 3.456e-02, 3.419e-02, 3.383e-02, 3.348e-02, 3.313e-02, 3.279e-02, 3.246e-02, 3.213e-02, - 3.181e-02, 3.119e-02, 3.059e-02, 3.002e-02, 2.947e-02, 2.893e-02, 2.842e-02, 2.792e-02, 2.744e-02, 2.698e-02, 2.653e-02, 2.610e-02, - 2.568e-02, 2.528e-02, 2.488e-02, 3.542e-05, 2.213e-02, 2.070e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.556e-02, 6.453e-02, - 6.353e-02, 6.256e-02, 6.163e-02, 6.072e-02, 6.036e-02, 6.001e-02, 5.966e-02, 5.932e-02, 5.898e-02, 5.864e-02, 5.831e-02, 5.799e-02, - 5.766e-02, 5.734e-02, 5.702e-02, 5.671e-02, 5.640e-02, 5.610e-02, 5.594e-02, 5.579e-02, 5.564e-02, 5.549e-02, 5.535e-02, 5.520e-02, - 5.505e-02, 5.490e-02, 5.476e-02, 5.461e-02, 5.447e-02, 5.433e-02, 5.419e-02, 5.404e-02, 5.390e-02, 5.376e-02, 5.362e-02, 5.349e-02, - 5.335e-02, 5.321e-02, 5.307e-02, 5.294e-02, 5.280e-02, 5.267e-02, 5.254e-02, 5.240e-02, 5.227e-02, 5.214e-02, 5.201e-02, 5.188e-02, - 5.175e-02, 5.162e-02, 5.136e-02, 5.111e-02, 5.086e-02, 5.061e-02, 5.036e-02, 5.012e-02, 4.988e-02, 4.964e-02, 4.940e-02, 4.917e-02, - 4.894e-02, 4.871e-02, 4.848e-02, 4.825e-02, 4.803e-02, 4.781e-02, 4.759e-02, 4.737e-02, 4.716e-02, 4.694e-02, 4.673e-02, 4.652e-02, - 4.632e-02, 4.611e-02, 4.591e-02, 4.540e-02, 4.491e-02, 4.443e-02, 4.396e-02, 4.350e-02, 4.305e-02, 4.261e-02, 4.218e-02, 4.175e-02, - 4.134e-02, 4.053e-02, 3.975e-02, 3.901e-02, 3.829e-02, 3.759e-02, 3.693e-02, 3.628e-02, 3.566e-02, 3.506e-02, 3.448e-02, 3.391e-02, - 3.337e-02, 3.284e-02, 3.233e-02, 3.542e-05, 2.875e-02, 2.689e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.315e-02, - 8.185e-02, 8.060e-02, 7.939e-02, 7.821e-02, 7.775e-02, 7.730e-02, 7.685e-02, 7.641e-02, 7.597e-02, 7.553e-02, 7.511e-02, 7.468e-02, - 7.426e-02, 7.385e-02, 7.344e-02, 7.304e-02, 7.264e-02, 7.224e-02, 7.205e-02, 7.185e-02, 7.166e-02, 7.147e-02, 7.128e-02, 7.108e-02, - 7.090e-02, 7.071e-02, 7.052e-02, 7.033e-02, 7.015e-02, 6.996e-02, 6.978e-02, 6.960e-02, 6.942e-02, 6.923e-02, 6.906e-02, 6.888e-02, - 6.870e-02, 6.852e-02, 6.835e-02, 6.817e-02, 6.800e-02, 6.782e-02, 6.765e-02, 6.748e-02, 6.731e-02, 6.714e-02, 6.697e-02, 6.680e-02, - 6.664e-02, 6.647e-02, 6.614e-02, 6.581e-02, 6.549e-02, 6.517e-02, 6.485e-02, 6.454e-02, 6.423e-02, 6.392e-02, 6.361e-02, 6.331e-02, - 6.301e-02, 6.272e-02, 6.242e-02, 6.213e-02, 6.185e-02, 6.156e-02, 6.128e-02, 6.100e-02, 6.072e-02, 6.044e-02, 6.017e-02, 5.990e-02, - 5.963e-02, 5.937e-02, 5.911e-02, 5.846e-02, 5.783e-02, 5.721e-02, 5.660e-02, 5.601e-02, 5.543e-02, 5.486e-02, 5.430e-02, 5.375e-02, - 5.322e-02, 5.218e-02, 5.118e-02, 5.022e-02, 4.929e-02, 4.840e-02, 4.754e-02, 4.671e-02, 4.591e-02, 4.513e-02, 4.438e-02, 4.366e-02, - 4.296e-02, 4.228e-02, 4.162e-02, 3.542e-05, 3.701e-02, 3.462e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.10460, 0.10290, 0.10140, 9.988e-02, 9.929e-02, 9.871e-02, 9.813e-02, 9.757e-02, 9.700e-02, 9.645e-02, 9.590e-02, 9.536e-02, - 9.482e-02, 9.430e-02, 9.377e-02, 9.325e-02, 9.274e-02, 9.224e-02, 9.199e-02, 9.174e-02, 9.149e-02, 9.124e-02, 9.100e-02, 9.075e-02, - 9.051e-02, 9.027e-02, 9.003e-02, 8.979e-02, 8.955e-02, 8.932e-02, 8.908e-02, 8.885e-02, 8.862e-02, 8.839e-02, 8.816e-02, 8.793e-02, - 8.770e-02, 8.747e-02, 8.725e-02, 8.703e-02, 8.680e-02, 8.658e-02, 8.636e-02, 8.614e-02, 8.592e-02, 8.571e-02, 8.549e-02, 8.528e-02, - 8.506e-02, 8.485e-02, 8.443e-02, 8.401e-02, 8.360e-02, 8.319e-02, 8.278e-02, 8.238e-02, 8.198e-02, 8.159e-02, 8.120e-02, 8.081e-02, - 8.043e-02, 8.005e-02, 7.968e-02, 7.931e-02, 7.894e-02, 7.857e-02, 7.821e-02, 7.786e-02, 7.750e-02, 7.715e-02, 7.680e-02, 7.646e-02, - 7.611e-02, 7.578e-02, 7.544e-02, 7.461e-02, 7.380e-02, 7.301e-02, 7.224e-02, 7.148e-02, 7.074e-02, 7.001e-02, 6.930e-02, 6.860e-02, - 6.792e-02, 6.659e-02, 6.532e-02, 6.409e-02, 6.291e-02, 6.177e-02, 6.067e-02, 5.961e-02, 5.859e-02, 5.760e-02, 5.664e-02, 5.572e-02, - 5.482e-02, 5.395e-02, 5.312e-02, 3.542e-05, 4.724e-02, 4.418e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.13040, 0.12840, 0.12650, 0.12580, 0.125, 0.12430, 0.12360, 0.12290, 0.12220, 0.12150, 0.12080, - 0.12010, 0.11940, 0.11870, 0.11810, 0.11740, 0.11680, 0.11650, 0.11620, 0.11580, 0.11550, 0.11520, 0.11490, - 0.11460, 0.11430, 0.114, 0.11370, 0.11340, 0.11310, 0.11280, 0.11250, 0.11220, 0.11190, 0.11160, 0.11130, - 0.111, 0.11080, 0.11050, 0.11020, 0.10990, 0.10960, 0.10930, 0.10910, 0.10880, 0.10850, 0.10820, 0.108, - 0.10770, 0.10740, 0.10690, 0.10640, 0.10580, 0.10530, 0.10480, 0.10430, 0.10380, 0.10330, 0.10280, 0.10230, - 0.10180, 0.10130, 0.10090, 0.10040, 9.993e-02, 9.946e-02, 9.901e-02, 9.855e-02, 9.810e-02, 9.766e-02, 9.722e-02, 9.678e-02, - 9.635e-02, 9.592e-02, 9.549e-02, 9.444e-02, 9.342e-02, 9.242e-02, 9.144e-02, 9.048e-02, 8.954e-02, 8.862e-02, 8.771e-02, 8.683e-02, - 8.597e-02, 8.429e-02, 8.267e-02, 8.112e-02, 7.962e-02, 7.818e-02, 7.678e-02, 7.544e-02, 7.415e-02, 7.289e-02, 7.168e-02, 7.051e-02, - 6.938e-02, 6.828e-02, 6.722e-02, 3.542e-05, 5.978e-02, 5.591e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.16150, 0.159, 0.15810, 0.15710, 0.15620, 0.15530, 0.15440, 0.15350, 0.15260, 0.15180, - 0.15090, 0.15, 0.14920, 0.14840, 0.14760, 0.14670, 0.14630, 0.14590, 0.14550, 0.14520, 0.14480, 0.14440, - 0.144, 0.14360, 0.14320, 0.14280, 0.14250, 0.14210, 0.14170, 0.14130, 0.141, 0.14060, 0.14020, 0.13990, - 0.13950, 0.13910, 0.13880, 0.13840, 0.13810, 0.13770, 0.13730, 0.137, 0.13660, 0.13630, 0.136, 0.13560, - 0.13530, 0.13490, 0.13430, 0.13360, 0.13290, 0.13230, 0.13160, 0.131, 0.13040, 0.12970, 0.12910, 0.12850, - 0.12790, 0.12730, 0.12670, 0.12610, 0.12550, 0.12490, 0.12430, 0.12380, 0.12320, 0.12260, 0.12210, 0.12150, - 0.121, 0.12050, 0.11990, 0.11860, 0.11730, 0.11610, 0.11480, 0.11360, 0.11240, 0.11130, 0.11010, 0.109, - 0.10790, 0.10580, 0.10380, 0.10190, 9.997e-02, 9.816e-02, 9.641e-02, 9.473e-02, 9.310e-02, 9.152e-02, 9.000e-02, 8.853e-02, - 8.711e-02, 8.573e-02, 8.440e-02, 3.542e-05, 7.505e-02, 7.019e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.19840, 0.19720, 0.19610, 0.19490, 0.19370, 0.19260, 0.19150, 0.19040, 0.18930, 0.18820, 0.18720, - 0.18610, 0.18510, 0.184, 0.183, 0.18250, 0.182, 0.18150, 0.181, 0.18050, 0.18, 0.17960, 0.17910, 0.17860, - 0.17810, 0.17760, 0.17720, 0.17670, 0.17620, 0.17580, 0.17530, 0.17480, 0.17440, 0.17390, 0.17350, 0.173, 0.17260, - 0.17210, 0.17170, 0.17120, 0.17080, 0.17040, 0.16990, 0.16950, 0.16910, 0.16870, 0.16820, 0.16740, 0.16660, 0.16570, - 0.16490, 0.16410, 0.16330, 0.16250, 0.16170, 0.16090, 0.16020, 0.15940, 0.15870, 0.15790, 0.15720, 0.15640, 0.15570, - 0.155, 0.15430, 0.15360, 0.15290, 0.15220, 0.15150, 0.15080, 0.15010, 0.14950, 0.14780, 0.14620, 0.14460, 0.14310, - 0.14160, 0.14010, 0.13870, 0.13730, 0.13590, 0.13450, 0.13190, 0.12940, 0.12690, 0.12460, 0.12230, 0.12010, 0.118, - 0.116, 0.11410, 0.11220, 0.11030, 0.10850, 0.10680, 0.10520, 3.542e-05, 9.352e-02, 8.746e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.21510, 0.21380, 0.21250, 0.21130, 0.21, 0.20880, 0.20760, 0.20640, 0.20520, 0.204, 0.20290, 0.20180, 0.20060, 0.19950, - 0.199, 0.19840, 0.19790, 0.19730, 0.19680, 0.19630, 0.19570, 0.19520, 0.19470, 0.19420, 0.19360, 0.19310, 0.19260, 0.19210, 0.19160, - 0.19110, 0.19060, 0.19010, 0.18960, 0.18910, 0.18860, 0.18810, 0.18760, 0.18720, 0.18670, 0.18620, 0.18570, 0.18520, 0.18480, 0.18430, - 0.18380, 0.18340, 0.18250, 0.18150, 0.18060, 0.17980, 0.17890, 0.178, 0.17710, 0.17630, 0.17540, 0.17460, 0.17380, 0.17290, 0.17210, - 0.17130, 0.17050, 0.16970, 0.16890, 0.16820, 0.16740, 0.16660, 0.16590, 0.16510, 0.16440, 0.16360, 0.16290, 0.16110, 0.15940, 0.15770, - 0.156, 0.15430, 0.15270, 0.15110, 0.14960, 0.14810, 0.14660, 0.14370, 0.141, 0.13830, 0.13580, 0.13330, 0.13090, 0.12860, 0.12640, - 0.12430, 0.12220, 0.12020, 0.11830, 0.11640, 0.11460, 3.542e-05, 0.10190, 9.531e-02}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.23290, 0.23150, 0.23010, 0.22870, 0.22740, 0.22610, 0.22480, 0.22350, 0.22220, 0.221, 0.21970, 0.21850, 0.21730, - 0.21670, 0.21610, 0.21550, 0.21490, 0.21430, 0.21370, 0.21310, 0.21260, 0.212, 0.21140, 0.21090, 0.21030, 0.20970, 0.20920, 0.20860, - 0.20810, 0.20750, 0.207, 0.20640, 0.20590, 0.20540, 0.20480, 0.20430, 0.20380, 0.20330, 0.20270, 0.20220, 0.20170, 0.20120, 0.20070, - 0.20020, 0.19970, 0.19870, 0.19770, 0.19670, 0.19570, 0.19480, 0.19380, 0.19290, 0.19190, 0.191, 0.19010, 0.18920, 0.18830, 0.18740, - 0.18650, 0.18560, 0.18480, 0.18390, 0.18310, 0.18220, 0.18140, 0.18060, 0.17980, 0.179, 0.17820, 0.17740, 0.17540, 0.17350, 0.17160, - 0.16980, 0.168, 0.16630, 0.16450, 0.16290, 0.16120, 0.15960, 0.15650, 0.15350, 0.15060, 0.14780, 0.14510, 0.14250, 0.14, 0.13760, - 0.13530, 0.133, 0.13090, 0.12880, 0.12670, 0.12480, 3.542e-05, 0.11090, 0.1037}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.25180, 0.25030, 0.24890, 0.24740, 0.246, 0.24450, 0.24310, 0.24170, 0.24040, 0.239, 0.23770, 0.23640, - 0.23570, 0.23510, 0.23440, 0.23380, 0.23310, 0.23250, 0.23190, 0.23120, 0.23060, 0.23, 0.22940, 0.22880, 0.22810, 0.22750, 0.22690, - 0.22630, 0.22570, 0.22510, 0.22460, 0.224, 0.22340, 0.22280, 0.22220, 0.22160, 0.22110, 0.22050, 0.21990, 0.21940, 0.21880, 0.21830, - 0.21770, 0.21720, 0.21610, 0.215, 0.21390, 0.21290, 0.21180, 0.21080, 0.20970, 0.20870, 0.20770, 0.20670, 0.20570, 0.20480, 0.20380, - 0.20280, 0.20190, 0.201, 0.2, 0.19910, 0.19820, 0.19730, 0.19640, 0.19550, 0.19460, 0.19370, 0.19290, 0.19080, 0.18870, 0.18660, - 0.18470, 0.18270, 0.18080, 0.17890, 0.17710, 0.17530, 0.17360, 0.17020, 0.16690, 0.16370, 0.16070, 0.15780, 0.155, 0.15230, 0.14960, - 0.14710, 0.14470, 0.14230, 0.14, 0.13780, 0.13560, 3.542e-05, 0.12060, 0.1128}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.27210, 0.27050, 0.26890, 0.26730, 0.26580, 0.26420, 0.26270, 0.26120, 0.25970, 0.25830, 0.25680, - 0.25610, 0.25540, 0.25470, 0.254, 0.25330, 0.25260, 0.25190, 0.25130, 0.25060, 0.24990, 0.24920, 0.24860, 0.24790, 0.24720, 0.24660, - 0.24590, 0.24530, 0.24460, 0.244, 0.24330, 0.24270, 0.24210, 0.24140, 0.24080, 0.24020, 0.23960, 0.239, 0.23840, 0.23770, 0.23710, - 0.23650, 0.23590, 0.23480, 0.23360, 0.23240, 0.23130, 0.23010, 0.229, 0.22790, 0.22680, 0.22570, 0.22460, 0.22350, 0.22250, 0.22140, - 0.22040, 0.21930, 0.21830, 0.21730, 0.21630, 0.21530, 0.21430, 0.21330, 0.21240, 0.21140, 0.21050, 0.20950, 0.20720, 0.205, 0.20270, - 0.20060, 0.19850, 0.19640, 0.19440, 0.19240, 0.19040, 0.18850, 0.18480, 0.18130, 0.17790, 0.17460, 0.17140, 0.16830, 0.16540, 0.16250, - 0.15980, 0.15710, 0.15460, 0.15210, 0.14970, 0.14730, 3.542e-05, 0.131, 0.1225}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.29370, 0.29190, 0.29020, 0.28850, 0.28690, 0.28520, 0.28360, 0.282, 0.28040, 0.27880, - 0.278, 0.27730, 0.27650, 0.27570, 0.275, 0.27420, 0.27350, 0.27270, 0.272, 0.27130, 0.27050, 0.26980, 0.26910, 0.26840, 0.26760, - 0.26690, 0.26620, 0.26550, 0.26480, 0.26410, 0.26340, 0.26280, 0.26210, 0.26140, 0.26070, 0.26, 0.25940, 0.25870, 0.258, 0.25740, - 0.25670, 0.25610, 0.25480, 0.25350, 0.25220, 0.251, 0.24980, 0.24850, 0.24730, 0.24610, 0.24490, 0.24370, 0.24260, 0.24140, 0.24030, - 0.23910, 0.238, 0.23690, 0.23580, 0.23470, 0.23360, 0.23260, 0.23150, 0.23050, 0.22940, 0.22840, 0.22740, 0.22490, 0.22240, 0.22, - 0.21770, 0.21540, 0.21310, 0.21090, 0.20880, 0.20660, 0.20460, 0.20060, 0.19670, 0.193, 0.18940, 0.186, 0.18270, 0.17950, 0.17640, - 0.17340, 0.17050, 0.16770, 0.165, 0.16240, 0.15990, 3.542e-05, 0.14210, 0.1329}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31660, 0.31480, 0.31290, 0.31110, 0.30930, 0.30760, 0.30580, 0.30410, 0.30240, - 0.30150, 0.30070, 0.29990, 0.299, 0.29820, 0.29740, 0.29660, 0.29580, 0.295, 0.29420, 0.29340, 0.29260, 0.29180, 0.291, 0.29020, - 0.28940, 0.28870, 0.28790, 0.28720, 0.28640, 0.28560, 0.28490, 0.28420, 0.28340, 0.28270, 0.282, 0.28120, 0.28050, 0.27980, 0.27910, - 0.27840, 0.27760, 0.27620, 0.27490, 0.27350, 0.27210, 0.27080, 0.26940, 0.26810, 0.26680, 0.26550, 0.26430, 0.263, 0.26170, 0.26050, - 0.25930, 0.258, 0.25680, 0.25560, 0.25450, 0.25330, 0.25210, 0.251, 0.24980, 0.24870, 0.24760, 0.24650, 0.24380, 0.24110, 0.23850, - 0.23590, 0.23350, 0.231, 0.22860, 0.22630, 0.224, 0.22170, 0.21740, 0.21320, 0.20920, 0.20530, 0.20160, 0.198, 0.19450, 0.19120, - 0.18790, 0.18480, 0.18180, 0.17880, 0.176, 0.17330, 3.542e-05, 0.154, 0.1441}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.34110, 0.33910, 0.33710, 0.33520, 0.33320, 0.33130, 0.32940, 0.32760, - 0.32670, 0.32580, 0.32490, 0.324, 0.32310, 0.32220, 0.32130, 0.32040, 0.31950, 0.31870, 0.31780, 0.31690, 0.31610, 0.31520, 0.31440, - 0.31350, 0.31270, 0.31190, 0.31110, 0.31020, 0.30940, 0.30860, 0.30780, 0.307, 0.30620, 0.30540, 0.30460, 0.30380, 0.30310, 0.30230, - 0.30150, 0.30070, 0.29920, 0.29770, 0.29620, 0.29470, 0.29330, 0.29180, 0.29040, 0.289, 0.28760, 0.28620, 0.28480, 0.28350, 0.28210, - 0.28080, 0.27950, 0.27820, 0.27690, 0.27560, 0.27430, 0.27310, 0.27180, 0.27060, 0.26930, 0.26810, 0.26690, 0.264, 0.26110, 0.25830, - 0.25550, 0.25280, 0.25020, 0.24760, 0.245, 0.24260, 0.24010, 0.23540, 0.23090, 0.22650, 0.22230, 0.21830, 0.21440, 0.21060, 0.207, - 0.20350, 0.20010, 0.19680, 0.19360, 0.19060, 0.18760, 3.542e-05, 0.16680, 0.156}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.36710, 0.36490, 0.36280, 0.36070, 0.35860, 0.35660, 0.35460, - 0.35360, 0.35260, 0.35160, 0.35060, 0.34960, 0.34870, 0.34770, 0.34680, 0.34580, 0.34490, 0.34390, 0.343, 0.34210, 0.34110, 0.34020, - 0.33930, 0.33840, 0.33750, 0.33660, 0.33570, 0.33480, 0.334, 0.33310, 0.33220, 0.33130, 0.33050, 0.32960, 0.32880, 0.32790, 0.32710, - 0.32630, 0.32540, 0.32380, 0.32210, 0.32050, 0.31890, 0.31730, 0.31580, 0.31420, 0.31270, 0.31120, 0.30970, 0.30820, 0.30670, 0.30520, - 0.30380, 0.30240, 0.30090, 0.29950, 0.29820, 0.29680, 0.29540, 0.29410, 0.29270, 0.29140, 0.29010, 0.28880, 0.28560, 0.28250, 0.27940, - 0.27640, 0.27350, 0.27060, 0.26780, 0.26510, 0.26240, 0.25980, 0.25460, 0.24970, 0.245, 0.24050, 0.23610, 0.23190, 0.22780, 0.22390, - 0.22010, 0.21640, 0.21290, 0.20940, 0.20610, 0.20290, 3.542e-05, 0.18040, 0.1687}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.39460, 0.39230, 0.39010, 0.38780, 0.38560, 0.38340, - 0.38230, 0.38120, 0.38020, 0.37910, 0.37810, 0.377, 0.376, 0.37490, 0.37390, 0.37290, 0.37190, 0.37080, 0.36980, 0.36880, 0.36780, - 0.36690, 0.36590, 0.36490, 0.36390, 0.363, 0.362, 0.361, 0.36010, 0.35920, 0.35820, 0.35730, 0.35640, 0.35540, 0.35450, 0.35360, - 0.35270, 0.35180, 0.35, 0.34820, 0.34650, 0.34470, 0.343, 0.34130, 0.33970, 0.338, 0.33640, 0.33470, 0.33310, 0.33150, 0.32990, - 0.32840, 0.32680, 0.32530, 0.32380, 0.32230, 0.32080, 0.31930, 0.31780, 0.31640, 0.315, 0.31350, 0.31210, 0.30870, 0.30530, 0.302, - 0.29870, 0.29560, 0.29250, 0.28940, 0.28650, 0.28360, 0.28070, 0.27520, 0.26990, 0.26480, 0.25990, 0.25510, 0.25060, 0.24620, 0.24190, - 0.23780, 0.23390, 0.23, 0.22630, 0.22270, 0.21930, 3.542e-05, 0.19490, 0.1823}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42390, 0.42140, 0.419, 0.41660, 0.41420, - 0.413, 0.41190, 0.41070, 0.40960, 0.40840, 0.40730, 0.40610, 0.405, 0.40390, 0.40280, 0.40170, 0.40060, 0.39950, 0.39840, 0.39730, - 0.39630, 0.39520, 0.39410, 0.39310, 0.392, 0.391, 0.39, 0.38890, 0.38790, 0.38690, 0.38590, 0.38490, 0.38390, 0.38290, 0.38190, - 0.38090, 0.37990, 0.378, 0.37610, 0.37420, 0.37230, 0.37050, 0.36860, 0.36680, 0.365, 0.36320, 0.36150, 0.35970, 0.358, 0.35630, - 0.35460, 0.35290, 0.35130, 0.34960, 0.348, 0.34640, 0.34480, 0.34320, 0.34160, 0.34010, 0.33860, 0.337, 0.33330, 0.32960, 0.32610, - 0.32260, 0.31910, 0.31580, 0.31250, 0.30930, 0.30620, 0.30310, 0.29710, 0.29140, 0.28590, 0.28060, 0.27540, 0.27050, 0.26580, 0.26120, - 0.25680, 0.25250, 0.24830, 0.24430, 0.24050, 0.23670, 3.542e-05, 0.21040, 0.1968}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.45490, 0.45230, 0.44970, 0.44710, - 0.44580, 0.44450, 0.44330, 0.442, 0.44080, 0.43960, 0.43830, 0.43710, 0.43590, 0.43470, 0.43350, 0.43230, 0.43110, 0.43, 0.42880, - 0.42760, 0.42650, 0.42530, 0.42420, 0.42310, 0.42190, 0.42080, 0.41970, 0.41860, 0.41750, 0.41640, 0.41530, 0.41420, 0.41320, 0.41210, - 0.411, 0.41, 0.40790, 0.40580, 0.40380, 0.40170, 0.39970, 0.39770, 0.39580, 0.39380, 0.39190, 0.39, 0.38810, 0.38620, 0.38440, - 0.38260, 0.38080, 0.379, 0.37720, 0.37540, 0.37370, 0.372, 0.37030, 0.36860, 0.36690, 0.36520, 0.36360, 0.35950, 0.35560, 0.35170, - 0.34790, 0.34420, 0.34060, 0.33710, 0.33360, 0.33020, 0.32690, 0.32050, 0.31430, 0.30830, 0.30260, 0.29710, 0.29180, 0.28660, 0.28170, - 0.27690, 0.27230, 0.26780, 0.26350, 0.25930, 0.25530, 3.542e-05, 0.22690, 0.2122}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.48780, 0.48490, 0.48210, - 0.48080, 0.47940, 0.478, 0.47670, 0.47530, 0.474, 0.47270, 0.47130, 0.47, 0.46870, 0.46740, 0.46620, 0.46490, 0.46360, 0.46230, - 0.46110, 0.45980, 0.45860, 0.45740, 0.45610, 0.45490, 0.45370, 0.45250, 0.45130, 0.45010, 0.44890, 0.44780, 0.44660, 0.44540, 0.44430, - 0.44310, 0.442, 0.43970, 0.43750, 0.43530, 0.43310, 0.43090, 0.42870, 0.42660, 0.42450, 0.42240, 0.42040, 0.41830, 0.41630, 0.41430, - 0.41240, 0.41040, 0.40850, 0.40650, 0.40460, 0.40280, 0.40090, 0.39910, 0.39720, 0.39540, 0.39360, 0.39190, 0.38750, 0.38320, 0.37910, - 0.375, 0.371, 0.36710, 0.36330, 0.35950, 0.35590, 0.35230, 0.34530, 0.33870, 0.33230, 0.32610, 0.32010, 0.31440, 0.30890, 0.30350, - 0.29840, 0.29340, 0.28860, 0.28390, 0.27940, 0.27510, 3.542e-05, 0.24450, 0.2287}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.52250, 0.51950, - 0.518, 0.51650, 0.51510, 0.51360, 0.51210, 0.51070, 0.50920, 0.50780, 0.50640, 0.505, 0.50360, 0.50220, 0.50080, 0.49940, 0.49810, - 0.49670, 0.49540, 0.494, 0.49270, 0.49140, 0.49010, 0.48870, 0.48740, 0.48610, 0.48490, 0.48360, 0.48230, 0.481, 0.47980, 0.47850, - 0.47730, 0.47610, 0.47360, 0.47120, 0.46880, 0.46640, 0.46410, 0.46180, 0.45950, 0.45720, 0.455, 0.45270, 0.45050, 0.44840, 0.44620, - 0.44410, 0.442, 0.43990, 0.43780, 0.43580, 0.43370, 0.43170, 0.42970, 0.42780, 0.42580, 0.42390, 0.422, 0.41730, 0.41270, 0.40820, - 0.40380, 0.39950, 0.39530, 0.39110, 0.38710, 0.38320, 0.37930, 0.37180, 0.36460, 0.35770, 0.35110, 0.34460, 0.33850, 0.33250, 0.32680, - 0.32120, 0.31590, 0.31070, 0.30570, 0.30080, 0.29610, 3.542e-05, 0.26320, 0.2461}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.55930, - 0.55770, 0.55610, 0.55450, 0.55290, 0.55130, 0.54980, 0.54820, 0.54670, 0.54510, 0.54360, 0.54210, 0.54060, 0.53910, 0.53760, 0.53610, - 0.53460, 0.53320, 0.53170, 0.53030, 0.52890, 0.52740, 0.526, 0.52460, 0.52320, 0.52180, 0.52050, 0.51910, 0.51770, 0.51640, 0.515, - 0.51370, 0.51230, 0.50970, 0.50710, 0.50450, 0.50190, 0.49940, 0.49690, 0.49440, 0.492, 0.48960, 0.48720, 0.48480, 0.48240, 0.48010, - 0.47780, 0.47550, 0.47330, 0.47110, 0.46880, 0.46670, 0.46450, 0.46230, 0.46020, 0.45810, 0.456, 0.454, 0.44890, 0.44390, 0.43910, - 0.43440, 0.42970, 0.42520, 0.42080, 0.41640, 0.41220, 0.408, 0.4, 0.39220, 0.38480, 0.37760, 0.37070, 0.36410, 0.35760, 0.35150, - 0.34550, 0.33970, 0.33410, 0.32870, 0.32350, 0.31850, 3.542e-05, 0.28310, 0.2647}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.57850, 0.57680, 0.57510, 0.57350, 0.57180, 0.57020, 0.56860, 0.567, 0.56540, 0.56380, 0.56220, 0.56070, 0.55910, 0.55760, 0.556, - 0.55450, 0.553, 0.55150, 0.55, 0.54850, 0.547, 0.54550, 0.54410, 0.54260, 0.54120, 0.53980, 0.53830, 0.53690, 0.53550, 0.53410, - 0.53270, 0.53130, 0.52860, 0.52590, 0.52320, 0.52050, 0.51790, 0.51530, 0.51270, 0.51020, 0.50770, 0.50520, 0.50270, 0.50030, 0.49790, - 0.49550, 0.49310, 0.49080, 0.48850, 0.48620, 0.48390, 0.48160, 0.47940, 0.47720, 0.475, 0.47290, 0.47070, 0.46550, 0.46030, 0.45530, - 0.45040, 0.44560, 0.44090, 0.43630, 0.43180, 0.42740, 0.423, 0.41470, 0.40660, 0.39890, 0.39150, 0.38430, 0.37740, 0.37080, 0.36440, - 0.35820, 0.35220, 0.34640, 0.34080, 0.33540, 0.33020, 3.542e-05, 0.29350, 0.2744}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.59820, 0.59640, 0.59470, 0.593, 0.59130, 0.58960, 0.588, 0.58630, 0.58470, 0.583, 0.58140, 0.57980, 0.57820, 0.57660, - 0.575, 0.57340, 0.57180, 0.57030, 0.56870, 0.56720, 0.56570, 0.56420, 0.56270, 0.56120, 0.55970, 0.55820, 0.55670, 0.55520, 0.55380, - 0.55230, 0.55090, 0.548, 0.54520, 0.54240, 0.53970, 0.53690, 0.53420, 0.53160, 0.52890, 0.52630, 0.52370, 0.52120, 0.51870, 0.51620, - 0.51370, 0.51120, 0.50880, 0.50640, 0.504, 0.50170, 0.49930, 0.497, 0.49470, 0.49250, 0.49020, 0.488, 0.48250, 0.47720, 0.472, - 0.46690, 0.46190, 0.457, 0.45220, 0.44760, 0.443, 0.43850, 0.42980, 0.42150, 0.41350, 0.40580, 0.39840, 0.39120, 0.38430, 0.37770, - 0.37130, 0.36510, 0.35910, 0.35330, 0.34760, 0.34220, 3.542e-05, 0.30420, 0.2844}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.61840, 0.61660, 0.61480, 0.61310, 0.61130, 0.60960, 0.60790, 0.60620, 0.60450, 0.60280, 0.60110, 0.59940, 0.59780, - 0.59610, 0.59450, 0.59280, 0.59120, 0.58960, 0.588, 0.58640, 0.58490, 0.58330, 0.58170, 0.58020, 0.57860, 0.57710, 0.57560, 0.57410, - 0.57260, 0.57110, 0.56810, 0.56520, 0.56230, 0.55940, 0.55660, 0.55380, 0.551, 0.54830, 0.54560, 0.54290, 0.54020, 0.53760, 0.535, - 0.53240, 0.52990, 0.52740, 0.52490, 0.52240, 0.52, 0.51750, 0.51510, 0.51280, 0.51040, 0.50810, 0.50580, 0.50010, 0.49460, 0.48920, - 0.48390, 0.47870, 0.47360, 0.46870, 0.46390, 0.45910, 0.45450, 0.44550, 0.43680, 0.42850, 0.42050, 0.41290, 0.40540, 0.39830, 0.39140, - 0.38470, 0.37830, 0.37210, 0.36610, 0.36030, 0.35460, 3.542e-05, 0.31520, 0.2948}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.63920, 0.63740, 0.63550, 0.63370, 0.63190, 0.63010, 0.62830, 0.62660, 0.62480, 0.623, 0.62130, 0.61960, - 0.61790, 0.61620, 0.61450, 0.61280, 0.61110, 0.60950, 0.60780, 0.60620, 0.60460, 0.60290, 0.60130, 0.59970, 0.59810, 0.59660, 0.595, - 0.59340, 0.59190, 0.58880, 0.58580, 0.58270, 0.57980, 0.57680, 0.57390, 0.571, 0.56820, 0.56540, 0.56260, 0.55990, 0.55710, 0.55440, - 0.55180, 0.54910, 0.54650, 0.54390, 0.54140, 0.53880, 0.53630, 0.53380, 0.53140, 0.52890, 0.52650, 0.52410, 0.51820, 0.51250, 0.50690, - 0.50140, 0.496, 0.49080, 0.48570, 0.48060, 0.47570, 0.47090, 0.46160, 0.45260, 0.444, 0.43570, 0.42780, 0.42010, 0.41270, 0.40550, - 0.39860, 0.392, 0.38550, 0.37930, 0.37330, 0.36740, 3.542e-05, 0.32660, 0.3054}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.66060, 0.65870, 0.65680, 0.65490, 0.653, 0.65120, 0.64930, 0.64750, 0.64570, 0.64390, 0.64210, - 0.64030, 0.63850, 0.63680, 0.635, 0.63330, 0.63160, 0.62990, 0.62820, 0.62650, 0.62480, 0.62310, 0.62150, 0.61980, 0.61820, 0.61650, - 0.61490, 0.61330, 0.61010, 0.607, 0.60380, 0.60070, 0.59770, 0.59470, 0.59170, 0.58870, 0.58580, 0.58290, 0.58010, 0.57720, 0.57440, - 0.57170, 0.56890, 0.56620, 0.56350, 0.56090, 0.55820, 0.55560, 0.55310, 0.55050, 0.548, 0.54550, 0.543, 0.53690, 0.53090, 0.52510, - 0.51940, 0.51390, 0.50840, 0.50310, 0.49790, 0.49280, 0.48780, 0.47820, 0.46890, 0.46, 0.45140, 0.44310, 0.43510, 0.42750, 0.42010, - 0.41290, 0.406, 0.39930, 0.39290, 0.38660, 0.38060, 3.542e-05, 0.33830, 0.3163}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.68250, 0.68050, 0.67860, 0.67660, 0.67470, 0.67280, 0.67090, 0.669, 0.66710, 0.66530, - 0.66340, 0.66160, 0.65980, 0.658, 0.65620, 0.65440, 0.65260, 0.65080, 0.64910, 0.64730, 0.64560, 0.64390, 0.64210, 0.64040, 0.63870, - 0.63710, 0.63540, 0.63210, 0.62880, 0.62550, 0.62230, 0.61920, 0.616, 0.61290, 0.60990, 0.60690, 0.60390, 0.60090, 0.598, 0.59510, - 0.59220, 0.58930, 0.58650, 0.58370, 0.581, 0.57830, 0.57560, 0.57290, 0.57020, 0.56760, 0.565, 0.56240, 0.55610, 0.54990, 0.54390, - 0.538, 0.53230, 0.52660, 0.52110, 0.51570, 0.51040, 0.50530, 0.49520, 0.48560, 0.47640, 0.46750, 0.45890, 0.45070, 0.44270, 0.435, - 0.42760, 0.42050, 0.41360, 0.40690, 0.40040, 0.39410, 3.542e-05, 0.35030, 0.3276}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.705, 0.703, 0.701, 0.699, 0.697, 0.695, 0.69310, 0.69110, 0.68920, - 0.68730, 0.68530, 0.68350, 0.68160, 0.67970, 0.67780, 0.676, 0.67420, 0.67230, 0.67050, 0.66870, 0.66690, 0.66510, 0.66340, 0.66160, - 0.65990, 0.65810, 0.65470, 0.65130, 0.64790, 0.64460, 0.64130, 0.63810, 0.63480, 0.63170, 0.62850, 0.62540, 0.62230, 0.61930, 0.61630, - 0.61330, 0.61040, 0.60740, 0.60460, 0.60170, 0.59890, 0.59610, 0.59330, 0.59050, 0.58780, 0.58510, 0.58250, 0.57590, 0.56950, 0.56330, - 0.55710, 0.55120, 0.54530, 0.53960, 0.534, 0.52860, 0.52320, 0.51280, 0.50280, 0.49330, 0.484, 0.47520, 0.46660, 0.45840, 0.45050, - 0.44280, 0.43540, 0.42820, 0.42130, 0.41460, 0.40810, 3.542e-05, 0.36270, 0.3391}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.72820, 0.72610, 0.724, 0.72190, 0.71990, 0.71780, 0.71580, 0.71380, - 0.71180, 0.70980, 0.70790, 0.70590, 0.704, 0.702, 0.70010, 0.69820, 0.69630, 0.69440, 0.69250, 0.69070, 0.68880, 0.687, 0.68520, - 0.68340, 0.68160, 0.678, 0.67450, 0.671, 0.66750, 0.66410, 0.66070, 0.65740, 0.65410, 0.65080, 0.64760, 0.64440, 0.64130, 0.63810, - 0.63510, 0.632, 0.629, 0.626, 0.623, 0.62010, 0.61720, 0.61430, 0.61150, 0.60860, 0.60580, 0.60310, 0.59630, 0.58960, 0.58320, - 0.57680, 0.57060, 0.56460, 0.55870, 0.55290, 0.54720, 0.54170, 0.53090, 0.52060, 0.51060, 0.50110, 0.49190, 0.48310, 0.47450, 0.46630, - 0.45840, 0.45070, 0.44330, 0.43610, 0.42920, 0.42240, 3.542e-05, 0.37540, 0.3511}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75190, 0.74970, 0.74760, 0.74550, 0.74330, 0.74120, 0.73920, - 0.73710, 0.735, 0.733, 0.73090, 0.72890, 0.72690, 0.72490, 0.723, 0.721, 0.719, 0.71710, 0.71520, 0.71320, 0.71130, 0.70940, - 0.70760, 0.70570, 0.702, 0.69830, 0.69470, 0.69110, 0.68760, 0.68410, 0.68060, 0.67720, 0.67380, 0.67050, 0.66720, 0.66390, 0.66060, - 0.65740, 0.65430, 0.65110, 0.648, 0.645, 0.64190, 0.63890, 0.63590, 0.633, 0.63010, 0.62720, 0.62430, 0.61730, 0.61040, 0.60370, - 0.59710, 0.59070, 0.58440, 0.57830, 0.57230, 0.56640, 0.56070, 0.54950, 0.53880, 0.52850, 0.51870, 0.50910, 0.5, 0.49120, 0.48260, - 0.47440, 0.46650, 0.45880, 0.45140, 0.44420, 0.43720, 3.542e-05, 0.38860, 0.3633}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.77630, 0.774, 0.77180, 0.76960, 0.76740, 0.76530, - 0.76310, 0.761, 0.75890, 0.75670, 0.75470, 0.75260, 0.75050, 0.74840, 0.74640, 0.74440, 0.74240, 0.74040, 0.73840, 0.73640, 0.73440, - 0.73250, 0.73050, 0.72670, 0.72290, 0.71910, 0.71540, 0.71170, 0.70810, 0.70450, 0.701, 0.69750, 0.694, 0.69060, 0.68720, 0.68380, - 0.68050, 0.67720, 0.674, 0.67070, 0.66760, 0.66440, 0.66130, 0.65820, 0.65510, 0.65210, 0.64910, 0.64610, 0.63880, 0.63170, 0.62480, - 0.618, 0.61130, 0.60480, 0.59850, 0.59230, 0.58620, 0.58020, 0.56870, 0.55760, 0.547, 0.53670, 0.52690, 0.51740, 0.50820, 0.49940, - 0.49090, 0.48270, 0.47470, 0.46710, 0.45960, 0.45240, 3.542e-05, 0.40210, 0.3759}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.80130, 0.799, 0.79670, 0.79440, 0.79220, - 0.78990, 0.78770, 0.78550, 0.78330, 0.78110, 0.779, 0.77680, 0.77470, 0.77260, 0.77050, 0.76840, 0.76630, 0.76420, 0.76220, 0.76010, - 0.75810, 0.75610, 0.75210, 0.74820, 0.74430, 0.74040, 0.73660, 0.73280, 0.72910, 0.72540, 0.72180, 0.71820, 0.71470, 0.71110, 0.70770, - 0.70420, 0.70080, 0.69740, 0.69410, 0.69080, 0.68750, 0.68430, 0.68110, 0.67790, 0.67480, 0.67170, 0.66860, 0.661, 0.65370, 0.64650, - 0.63940, 0.63250, 0.62580, 0.61920, 0.61280, 0.60650, 0.60030, 0.58840, 0.57690, 0.56590, 0.55530, 0.54510, 0.53530, 0.52580, 0.51670, - 0.50790, 0.49940, 0.49110, 0.48320, 0.47550, 0.468, 3.542e-05, 0.41590, 0.3889}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.82690, 0.82460, 0.82220, 0.81990, - 0.81750, 0.81520, 0.81290, 0.81070, 0.80840, 0.80620, 0.80390, 0.80170, 0.79950, 0.79730, 0.79520, 0.793, 0.79090, 0.78870, 0.78660, - 0.78450, 0.78240, 0.77830, 0.77420, 0.77010, 0.76610, 0.76220, 0.75830, 0.75440, 0.75060, 0.74690, 0.74310, 0.73940, 0.73580, 0.73220, - 0.72860, 0.72510, 0.72160, 0.71810, 0.71470, 0.71130, 0.708, 0.70470, 0.70140, 0.69810, 0.69490, 0.69170, 0.68390, 0.67630, 0.66880, - 0.66150, 0.65440, 0.64740, 0.64060, 0.63390, 0.62740, 0.621, 0.60870, 0.59680, 0.58540, 0.57440, 0.56390, 0.55370, 0.54390, 0.53450, - 0.52530, 0.51650, 0.508, 0.49980, 0.49180, 0.48410, 3.542e-05, 0.43020, 0.4023}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.85320, 0.85080, 0.84840, - 0.846, 0.84360, 0.84120, 0.83880, 0.83650, 0.83410, 0.83180, 0.82950, 0.82730, 0.825, 0.82270, 0.82050, 0.81830, 0.81610, 0.81390, - 0.81170, 0.80950, 0.80520, 0.801, 0.79680, 0.79260, 0.78850, 0.78450, 0.78050, 0.77650, 0.77260, 0.76880, 0.76490, 0.76120, 0.75740, - 0.75370, 0.75010, 0.74650, 0.74290, 0.73930, 0.73580, 0.73240, 0.72890, 0.72550, 0.72210, 0.71880, 0.71550, 0.70740, 0.69950, 0.69180, - 0.68420, 0.67680, 0.66960, 0.66260, 0.65570, 0.64890, 0.64230, 0.62950, 0.61720, 0.60540, 0.59410, 0.58310, 0.57260, 0.56250, 0.55270, - 0.54330, 0.53420, 0.52540, 0.51690, 0.50860, 0.50060, 3.542e-05, 0.44490, 0.416}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.88020, 0.87770, - 0.87520, 0.87270, 0.87030, 0.86780, 0.86540, 0.86290, 0.86050, 0.85820, 0.85580, 0.85340, 0.85110, 0.84880, 0.84650, 0.84420, 0.84190, - 0.83960, 0.83740, 0.83290, 0.82850, 0.82420, 0.81990, 0.81560, 0.81140, 0.80730, 0.80320, 0.79920, 0.79510, 0.79120, 0.78730, 0.78340, - 0.77960, 0.77580, 0.772, 0.76830, 0.76460, 0.761, 0.75740, 0.75390, 0.75030, 0.74680, 0.74340, 0.74, 0.73160, 0.72340, 0.71540, - 0.70760, 0.69990, 0.69240, 0.68510, 0.678, 0.671, 0.66420, 0.65090, 0.63820, 0.626, 0.61430, 0.603, 0.59210, 0.58160, 0.57150, - 0.56170, 0.55230, 0.54320, 0.53440, 0.52590, 0.51760, 3.542e-05, 0.46, 0.4301}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.90790, - 0.90530, 0.90270, 0.90020, 0.89760, 0.89510, 0.89260, 0.89010, 0.88760, 0.88520, 0.88270, 0.88030, 0.87790, 0.87550, 0.87310, 0.87070, - 0.86840, 0.86610, 0.86140, 0.85690, 0.85240, 0.84790, 0.84350, 0.83920, 0.83490, 0.83060, 0.82640, 0.82230, 0.81820, 0.81410, 0.81010, - 0.80610, 0.80220, 0.79830, 0.79450, 0.79070, 0.78690, 0.78320, 0.77950, 0.77590, 0.77220, 0.76870, 0.76510, 0.75640, 0.74790, 0.73970, - 0.73160, 0.72370, 0.71590, 0.70840, 0.701, 0.69380, 0.68670, 0.673, 0.65980, 0.64720, 0.635, 0.62340, 0.61210, 0.60130, 0.59080, - 0.58070, 0.571, 0.56150, 0.55240, 0.54360, 0.53510, 3.542e-05, 0.47550, 0.4446}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.93630, 0.93360, 0.931, 0.92830, 0.92570, 0.92310, 0.92050, 0.91790, 0.91540, 0.91280, 0.91030, 0.90780, 0.90530, 0.90290, 0.90040, - 0.898, 0.89560, 0.89080, 0.886, 0.88140, 0.87680, 0.87220, 0.86770, 0.86320, 0.85880, 0.85450, 0.85020, 0.84590, 0.84170, 0.83760, - 0.83340, 0.82940, 0.82540, 0.82140, 0.81740, 0.81350, 0.80970, 0.80590, 0.80210, 0.79840, 0.79460, 0.791, 0.782, 0.77320, 0.76460, - 0.75620, 0.74810, 0.74010, 0.73220, 0.72460, 0.71710, 0.70980, 0.69560, 0.682, 0.66890, 0.65640, 0.64430, 0.63270, 0.62150, 0.61060, - 0.60020, 0.59010, 0.58040, 0.571, 0.56190, 0.553, 3.542e-05, 0.49140, 0.4594}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.96540, 0.96260, 0.95990, 0.95720, 0.95450, 0.95180, 0.94910, 0.94650, 0.94380, 0.94120, 0.93860, 0.93610, 0.93350, 0.93090, - 0.92840, 0.92590, 0.92090, 0.916, 0.91120, 0.90640, 0.90170, 0.897, 0.89240, 0.88780, 0.88330, 0.87890, 0.87450, 0.87010, 0.86580, - 0.86150, 0.85730, 0.85320, 0.849, 0.845, 0.84090, 0.83690, 0.833, 0.82910, 0.82520, 0.82140, 0.81760, 0.80830, 0.79920, 0.79030, - 0.78160, 0.77310, 0.76490, 0.75680, 0.74890, 0.74110, 0.73360, 0.71890, 0.70480, 0.69130, 0.67830, 0.66580, 0.65380, 0.64220, 0.631, - 0.62020, 0.60980, 0.59970, 0.59, 0.58060, 0.57150, 3.542e-05, 0.50780, 0.4747}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.99520, 0.99240, 0.98950, 0.98670, 0.984, 0.98120, 0.97840, 0.97570, 0.973, 0.97030, 0.96760, 0.965, 0.96230, - 0.95970, 0.95710, 0.952, 0.94690, 0.94190, 0.93690, 0.932, 0.92720, 0.92240, 0.91770, 0.913, 0.90840, 0.90380, 0.89930, 0.89480, - 0.89040, 0.88610, 0.88170, 0.87750, 0.87320, 0.86910, 0.86490, 0.86080, 0.85680, 0.85280, 0.84880, 0.84490, 0.83520, 0.82580, 0.81670, - 0.80770, 0.79890, 0.79040, 0.782, 0.77380, 0.76580, 0.758, 0.74280, 0.72830, 0.71430, 0.70090, 0.68790, 0.67550, 0.66350, 0.652, - 0.64080, 0.63, 0.61960, 0.60960, 0.59980, 0.59040, 3.542e-05, 0.52460, 0.4905}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 1.026, 1.023, 1.02, 1.017, 1.014, 1.011, 1.008, 1.006, 1.003, 1.0, 0.99740, 0.99460, - 0.99190, 0.98920, 0.98390, 0.97860, 0.97340, 0.96830, 0.96320, 0.95820, 0.95320, 0.94830, 0.94350, 0.93870, 0.934, 0.92930, 0.92470, - 0.92010, 0.91560, 0.91110, 0.90670, 0.90230, 0.898, 0.89370, 0.88950, 0.88530, 0.88110, 0.877, 0.873, 0.863, 0.85330, 0.84380, - 0.83450, 0.82540, 0.81660, 0.80790, 0.79940, 0.79120, 0.78310, 0.76740, 0.75230, 0.73790, 0.724, 0.71060, 0.69780, 0.68540, 0.67350, - 0.66190, 0.65080, 0.64010, 0.62970, 0.61960, 0.60990, 3.542e-05, 0.54180, 0.5066}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 1.057, 1.054, 1.051, 1.048, 1.045, 1.042, 1.039, 1.036, 1.034, 1.031, 1.028, - 1.025, 1.022, 1.017, 1.011, 1.006, 1.0, 0.99520, 0.99, 0.98490, 0.97980, 0.97480, 0.96990, 0.965, 0.96010, 0.95530, - 0.95060, 0.94590, 0.94130, 0.93670, 0.93220, 0.92770, 0.92330, 0.91890, 0.91460, 0.91030, 0.906, 0.90180, 0.89150, 0.88140, 0.87160, - 0.862, 0.85260, 0.84350, 0.83450, 0.82580, 0.81720, 0.80880, 0.79260, 0.77710, 0.76210, 0.74780, 0.734, 0.72070, 0.70790, 0.69550, - 0.68360, 0.67210, 0.661, 0.65030, 0.63990, 0.62980, 3.542e-05, 0.55960, 0.5232}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 1.089, 1.086, 1.083, 1.08, 1.077, 1.074, 1.071, 1.068, 1.065, 1.062, - 1.059, 1.056, 1.05, 1.045, 1.039, 1.034, 1.028, 1.023, 1.017, 1.012, 1.007, 1.002, 0.99680, 0.99180, 0.98680, - 0.982, 0.97710, 0.97230, 0.96760, 0.96290, 0.95830, 0.95370, 0.94910, 0.94470, 0.94020, 0.93580, 0.93150, 0.92080, 0.91040, 0.90020, - 0.89030, 0.88060, 0.87110, 0.86190, 0.85280, 0.844, 0.83530, 0.81850, 0.80250, 0.787, 0.77220, 0.75790, 0.74420, 0.731, 0.71820, - 0.70590, 0.694, 0.68260, 0.67150, 0.66070, 0.65030, 3.542e-05, 0.57780, 0.5402}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.122, 1.119, 1.116, 1.113, 1.109, 1.106, 1.103, 1.1, 1.097, - 1.094, 1.091, 1.085, 1.079, 1.073, 1.068, 1.062, 1.056, 1.051, 1.045, 1.04, 1.035, 1.03, 1.024, 1.019, - 1.014, 1.009, 1.004, 0.99930, 0.99440, 0.98960, 0.98490, 0.98020, 0.97560, 0.971, 0.96640, 0.96190, 0.95090, 0.94010, 0.92960, - 0.91930, 0.90930, 0.89950, 0.88990, 0.88060, 0.87140, 0.86250, 0.84510, 0.82850, 0.81260, 0.79730, 0.78250, 0.76830, 0.75470, 0.74150, - 0.72880, 0.71650, 0.70470, 0.69320, 0.68210, 0.67140, 3.542e-05, 0.59640, 0.5576}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.156, 1.152, 1.149, 1.146, 1.143, 1.139, 1.136, 1.133, - 1.13, 1.127, 1.121, 1.115, 1.109, 1.103, 1.097, 1.091, 1.085, 1.08, 1.074, 1.069, 1.063, 1.058, 1.052, - 1.047, 1.042, 1.037, 1.032, 1.027, 1.022, 1.017, 1.012, 1.007, 1.003, 0.99790, 0.99320, 0.98180, 0.97060, 0.95970, - 0.94910, 0.93880, 0.92860, 0.91880, 0.90910, 0.89960, 0.89040, 0.87250, 0.85530, 0.83880, 0.823, 0.80780, 0.79310, 0.779, 0.76540, - 0.75230, 0.73960, 0.72740, 0.71550, 0.70410, 0.693, 3.542e-05, 0.61560, 0.5755}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.19, 1.187, 1.183, 1.18, 1.177, 1.173, 1.17, - 1.167, 1.164, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.121, 1.115, 1.109, 1.103, 1.098, 1.092, 1.087, - 1.081, 1.076, 1.071, 1.065, 1.06, 1.055, 1.05, 1.045, 1.04, 1.035, 1.03, 1.025, 1.013, 1.002, 0.99070, - 0.97970, 0.969, 0.95860, 0.94840, 0.93840, 0.92860, 0.919, 0.90050, 0.88280, 0.86580, 0.84940, 0.83370, 0.81860, 0.804, 0.78990, - 0.77640, 0.76330, 0.75070, 0.73840, 0.72660, 0.71520, 3.542e-05, 0.63530, 0.5939}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.226, 1.222, 1.219, 1.215, 1.212, 1.208, - 1.205, 1.202, 1.195, 1.188, 1.182, 1.176, 1.169, 1.163, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.122, - 1.116, 1.111, 1.105, 1.1, 1.094, 1.089, 1.084, 1.079, 1.073, 1.068, 1.063, 1.058, 1.046, 1.034, 1.023, - 1.011, 1.0, 0.98930, 0.97870, 0.96840, 0.95830, 0.94840, 0.92930, 0.911, 0.89340, 0.87650, 0.86030, 0.84470, 0.82960, 0.81510, - 0.80110, 0.78760, 0.77460, 0.76190, 0.74970, 0.73790, 3.542e-05, 0.65550, 0.6128}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.262, 1.258, 1.254, 1.251, 1.247, - 1.244, 1.24, 1.234, 1.227, 1.22, 1.213, 1.207, 1.201, 1.194, 1.188, 1.182, 1.176, 1.17, 1.164, 1.158, - 1.152, 1.146, 1.141, 1.135, 1.129, 1.124, 1.118, 1.113, 1.108, 1.102, 1.097, 1.092, 1.08, 1.067, 1.055, - 1.043, 1.032, 1.021, 1.01, 0.99920, 0.98880, 0.97860, 0.95890, 0.93990, 0.92180, 0.90440, 0.88760, 0.87150, 0.85590, 0.84090, - 0.82650, 0.81260, 0.79910, 0.78610, 0.77350, 0.76130, 3.542e-05, 0.67620, 0.6321}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.299, 1.295, 1.291, 1.288, - 1.284, 1.28, 1.273, 1.266, 1.259, 1.252, 1.246, 1.239, 1.232, 1.226, 1.22, 1.213, 1.207, 1.201, 1.195, - 1.189, 1.183, 1.177, 1.171, 1.165, 1.16, 1.154, 1.149, 1.143, 1.138, 1.132, 1.127, 1.114, 1.101, 1.089, - 1.077, 1.065, 1.053, 1.042, 1.031, 1.02, 1.01, 0.98920, 0.96960, 0.95090, 0.93290, 0.91560, 0.89890, 0.88290, 0.86740, - 0.85250, 0.83810, 0.82420, 0.81080, 0.79780, 0.78520, 3.542e-05, 0.69740, 0.652}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.337, 1.333, 1.329, - 1.325, 1.321, 1.314, 1.307, 1.3, 1.292, 1.285, 1.279, 1.272, 1.265, 1.258, 1.252, 1.245, 1.239, 1.233, - 1.227, 1.22, 1.214, 1.208, 1.202, 1.196, 1.191, 1.185, 1.179, 1.174, 1.168, 1.163, 1.149, 1.136, 1.123, - 1.111, 1.098, 1.086, 1.075, 1.063, 1.052, 1.041, 1.02, 1.0, 0.98080, 0.96220, 0.94430, 0.92710, 0.91060, 0.89460, - 0.87920, 0.86440, 0.85, 0.83620, 0.82280, 0.80980, 3.542e-05, 0.7192, 0.6723}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.375, 1.371, - 1.367, 1.364, 1.356, 1.348, 1.341, 1.334, 1.326, 1.319, 1.312, 1.305, 1.298, 1.292, 1.285, 1.278, 1.272, - 1.265, 1.259, 1.253, 1.246, 1.24, 1.234, 1.228, 1.222, 1.216, 1.211, 1.205, 1.199, 1.185, 1.172, 1.158, - 1.145, 1.133, 1.12, 1.108, 1.097, 1.085, 1.074, 1.052, 1.031, 1.011, 0.99220, 0.97380, 0.956, 0.939, 0.92250, - 0.90660, 0.89130, 0.87650, 0.86220, 0.84840, 0.835, 3.542e-05, 0.7416, 0.6932}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.415, - 1.411, 1.407, 1.399, 1.391, 1.383, 1.376, 1.368, 1.361, 1.354, 1.346, 1.339, 1.332, 1.325, 1.319, 1.312, - 1.305, 1.299, 1.292, 1.286, 1.279, 1.273, 1.267, 1.261, 1.255, 1.249, 1.243, 1.237, 1.222, 1.208, 1.195, - 1.181, 1.168, 1.155, 1.143, 1.131, 1.119, 1.107, 1.085, 1.063, 1.043, 1.023, 1.004, 0.98570, 0.96810, 0.95110, - 0.93470, 0.91890, 0.90360, 0.88890, 0.87460, 0.86080, 3.542e-05, 0.7645, 0.7146}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 1.455, 1.451, 1.443, 1.435, 1.427, 1.419, 1.411, 1.404, 1.396, 1.389, 1.381, 1.374, 1.367, 1.36, 1.353, - 1.346, 1.339, 1.332, 1.326, 1.319, 1.313, 1.306, 1.3, 1.294, 1.287, 1.281, 1.275, 1.26, 1.246, 1.232, - 1.218, 1.204, 1.191, 1.178, 1.166, 1.154, 1.142, 1.118, 1.096, 1.075, 1.055, 1.035, 1.016, 0.99790, 0.98040, - 0.96350, 0.94720, 0.93140, 0.91620, 0.90150, 0.88730, 3.542e-05, 0.7879, 0.7365}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.497, 1.488, 1.48, 1.472, 1.464, 1.456, 1.448, - 1.44, 1.432, 1.425, 1.417, 1.41, 1.402, 1.395, 1.388, 1.381, 1.374, 1.367, 1.36, 1.354, 1.347, 1.34, 1.334, 1.327, - 1.321, 1.315, 1.299, 1.284, 1.27, 1.255, 1.242, 1.228, 1.215, 1.202, 1.189, 1.177, 1.153, 1.13, 1.108, 1.087, 1.067, - 1.047, 1.028, 1.01, 0.993, 0.97620, 0.95990, 0.94420, 0.92910, 0.91440, 3.542e-05, 0.812, 0.759}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.583, 1.574, 1.565, 1.556, 1.548, 1.539, - 1.531, 1.522, 1.514, 1.506, 1.498, 1.49, 1.483, 1.475, 1.468, 1.46, 1.453, 1.445, 1.438, 1.431, 1.424, 1.417, 1.41, - 1.404, 1.397, 1.38, 1.364, 1.349, 1.334, 1.319, 1.304, 1.29, 1.276, 1.263, 1.25, 1.224, 1.2, 1.177, 1.154, 1.133, - 1.112, 1.092, 1.073, 1.054, 1.036, 1.019, 1.002, 0.98630, 0.97070, 3.542e-05, 0.8619, 0.8056}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.673, 1.663, 1.654, 1.644, 1.635, - 1.626, 1.617, 1.609, 1.6, 1.592, 1.583, 1.575, 1.567, 1.559, 1.551, 1.543, 1.535, 1.527, 1.52, 1.512, 1.505, 1.498, - 1.49, 1.483, 1.466, 1.449, 1.432, 1.416, 1.4, 1.385, 1.37, 1.355, 1.341, 1.327, 1.299, 1.273, 1.249, 1.225, 1.202, - 1.18, 1.159, 1.138, 1.119, 1.1, 1.081, 1.063, 1.046, 1.03, 3.542e-05, 0.9143, 0.8546}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.766, 1.756, 1.746, 1.737, - 1.727, 1.717, 1.708, 1.699, 1.69, 1.681, 1.672, 1.663, 1.655, 1.646, 1.638, 1.629, 1.621, 1.613, 1.605, 1.597, 1.589, - 1.582, 1.574, 1.555, 1.537, 1.519, 1.502, 1.485, 1.469, 1.453, 1.437, 1.422, 1.407, 1.378, 1.351, 1.324, 1.299, 1.274, - 1.251, 1.229, 1.207, 1.186, 1.166, 1.146, 1.128, 1.109, 1.092, 3.542e-05, 0.9692, 0.9059}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.864, 1.854, 1.843, - 1.833, 1.823, 1.813, 1.803, 1.793, 1.784, 1.774, 1.765, 1.755, 1.746, 1.737, 1.729, 1.72, 1.711, 1.703, 1.694, 1.686, - 1.678, 1.669, 1.649, 1.63, 1.611, 1.593, 1.575, 1.557, 1.54, 1.524, 1.507, 1.492, 1.461, 1.432, 1.403, 1.377, 1.351, - 1.326, 1.302, 1.279, 1.257, 1.235, 1.215, 1.195, 1.175, 1.157, 3.542e-05, 1.027, 0.9597}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.967, 1.955, 1.944, 1.933, 1.923, 1.912, 1.902, 1.891, 1.881, 1.871, - 1.861, 1.852, 1.842, 1.833, 1.823, 1.814, 1.805, 1.796, 1.787, 1.778, 1.77, 1.748, 1.728, 1.707, 1.688, 1.669, 1.65, 1.632, 1.614, - 1.597, 1.58, 1.548, 1.516, 1.487, 1.458, 1.431, 1.404, 1.379, 1.354, 1.331, 1.308, 1.286, 1.265, 1.245, 1.225, 3.542e-05, 1.087, 1.016}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.074, 2.062, 2.05, 2.038, 2.027, 2.016, 2.005, 1.994, 1.983, - 1.973, 1.962, 1.952, 1.942, 1.932, 1.922, 1.912, 1.903, 1.893, 1.884, 1.875, 1.852, 1.83, 1.809, 1.788, 1.767, 1.748, 1.728, 1.709, - 1.691, 1.673, 1.639, 1.605, 1.574, 1.543, 1.514, 1.486, 1.459, 1.434, 1.409, 1.384, 1.361, 1.339, 1.317, 1.296, 3.542e-05, 1.15, 1.075}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.185, 2.172, 2.16, 2.148, 2.136, 2.124, 2.112, 2.101, - 2.09, 2.079, 2.068, 2.057, 2.046, 2.036, 2.025, 2.015, 2.005, 1.995, 1.985, 1.961, 1.937, 1.915, 1.892, 1.871, 1.85, 1.829, 1.809, - 1.79, 1.771, 1.734, 1.699, 1.665, 1.633, 1.602, 1.572, 1.544, 1.516, 1.49, 1.464, 1.44, 1.416, 1.393, 1.371, 3.542e-05, 1.216, 1.137}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.301, 2.288, 2.275, 2.262, 2.249, 2.237, 2.225, - 2.213, 2.201, 2.189, 2.177, 2.166, 2.155, 2.144, 2.133, 2.122, 2.111, 2.101, 2.075, 2.05, 2.026, 2.002, 1.979, 1.957, 1.935, 1.914, - 1.893, 1.873, 1.834, 1.796, 1.761, 1.727, 1.694, 1.662, 1.632, 1.603, 1.575, 1.548, 1.522, 1.497, 1.473, 1.449, 3.542e-05, 1.286, 1.201}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.422, 2.408, 2.394, 2.381, 2.367, 2.354, - 2.341, 2.329, 2.316, 2.304, 2.292, 2.28, 2.268, 2.256, 2.245, 2.233, 2.222, 2.195, 2.168, 2.142, 2.117, 2.093, 2.069, 2.046, 2.023, - 2.001, 1.98, 1.938, 1.899, 1.861, 1.825, 1.79, 1.757, 1.725, 1.694, 1.664, 1.635, 1.608, 1.581, 1.556, 1.531, 3.542e-05, 1.358, 1.269}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.548, 2.533, 2.519, 2.505, 2.491, - 2.477, 2.463, 2.45, 2.437, 2.424, 2.411, 2.398, 2.386, 2.373, 2.361, 2.349, 2.32, 2.292, 2.264, 2.238, 2.212, 2.186, 2.162, 2.138, - 2.114, 2.091, 2.048, 2.006, 1.965, 1.927, 1.89, 1.855, 1.821, 1.789, 1.757, 1.727, 1.698, 1.67, 1.642, 1.616, 3.542e-05, 1.433, 1.339}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.679, 2.664, 2.648, 2.633, - 2.619, 2.604, 2.59, 2.576, 2.562, 2.548, 2.535, 2.522, 2.508, 2.495, 2.483, 2.452, 2.421, 2.392, 2.364, 2.336, 2.309, 2.283, 2.258, - 2.233, 2.209, 2.162, 2.117, 2.075, 2.034, 1.995, 1.958, 1.922, 1.888, 1.854, 1.822, 1.792, 1.762, 1.733, 1.705, 3.542e-05, 1.512, 1.413}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.816, 2.8, 2.783, - 2.768, 2.752, 2.737, 2.722, 2.707, 2.692, 2.678, 2.664, 2.65, 2.636, 2.622, 2.589, 2.557, 2.526, 2.496, 2.466, 2.438, 2.41, 2.383, - 2.357, 2.331, 2.282, 2.234, 2.189, 2.146, 2.105, 2.066, 2.028, 1.991, 1.956, 1.922, 1.89, 1.858, 1.828, 1.799, 3.542e-05, 1.595, 1.490}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.958, 2.941, - 2.924, 2.907, 2.891, 2.875, 2.859, 2.843, 2.828, 2.813, 2.798, 2.783, 2.769, 2.733, 2.699, 2.666, 2.634, 2.603, 2.572, 2.543, 2.514, - 2.486, 2.459, 2.407, 2.357, 2.309, 2.263, 2.22, 2.178, 2.138, 2.099, 2.062, 2.026, 1.992, 1.959, 1.927, 1.896, 3.542e-05, 1.681, 1.570}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.106, - 3.088, 3.07, 3.052, 3.035, 3.018, 3.001, 2.985, 2.969, 2.953, 2.937, 2.922, 2.884, 2.848, 2.812, 2.778, 2.745, 2.713, 2.682, 2.651, - 2.622, 2.593, 2.537, 2.484, 2.434, 2.386, 2.34, 2.295, 2.253, 2.212, 2.173, 2.135, 2.099, 2.064, 2.03, 1.997, 3.542e-05, 1.77, 1.654}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 3.26, 3.24, 3.222, 3.203, 3.185, 3.167, 3.15, 3.132, 3.115, 3.099, 3.082, 3.042, 3.003, 2.966, 2.929, 2.894, 2.86, 2.827, 2.794, - 2.763, 2.732, 2.674, 2.618, 2.564, 2.513, 2.465, 2.418, 2.373, 2.33, 2.289, 2.249, 2.21, 2.173, 2.138, 2.103, 3.542e-05, 1.864, 1.741}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 3.419, 3.399, 3.379, 3.36, 3.341, 3.322, 3.304, 3.286, 3.268, 3.25, 3.207, 3.166, 3.126, 3.087, 3.05, 3.014, 2.978, 2.944, - 2.911, 2.878, 2.816, 2.757, 2.7, 2.646, 2.595, 2.546, 2.498, 2.453, 2.409, 2.367, 2.326, 2.287, 2.25, 2.213, 3.542e-05, 1.961, 1.832}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 3.585, 3.564, 3.543, 3.523, 3.503, 3.483, 3.464, 3.445, 3.426, 3.38, 3.336, 3.294, 3.253, 3.213, 3.174, 3.137, 3.1, - 3.065, 3.031, 2.965, 2.902, 2.842, 2.785, 2.731, 2.679, 2.629, 2.581, 2.535, 2.49, 2.448, 2.406, 2.367, 2.328, 3.542e-05, 2.063, 1.926}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 3.758, 3.735, 3.713, 3.692, 3.671, 3.65, 3.63, 3.61, 3.561, 3.514, 3.469, 3.425, 3.383, 3.342, 3.302, 3.264, - 3.226, 3.19, 3.12, 3.054, 2.99, 2.93, 2.873, 2.818, 2.765, 2.714, 2.665, 2.619, 2.574, 2.53, 2.488, 2.448, 3.542e-05, 2.168, 2.025}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 3.937, 3.913, 3.89, 3.867, 3.845, 3.823, 3.802, 3.75, 3.7, 3.652, 3.605, 3.561, 3.517, 3.475, 3.434, - 3.394, 3.356, 3.282, 3.212, 3.145, 3.081, 3.02, 2.962, 2.907, 2.853, 2.802, 2.752, 2.705, 2.659, 2.615, 2.573, 3.542e-05, 2.278, 2.127}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 4.122, 4.097, 4.073, 4.049, 4.026, 4.003, 3.948, 3.895, 3.843, 3.794, 3.746, 3.7, 3.655, 3.612, - 3.57, 3.529, 3.451, 3.376, 3.306, 3.238, 3.174, 3.113, 3.054, 2.998, 2.944, 2.892, 2.842, 2.794, 2.747, 2.702, 3.542e-05, 2.392, 2.234}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.315, 4.289, 4.263, 4.238, 4.214, 4.155, 4.098, 4.043, 3.991, 3.94, 3.891, 3.843, 3.797, - 3.753, 3.709, 3.627, 3.548, 3.473, 3.402, 3.335, 3.27, 3.208, 3.148, 3.091, 3.037, 2.984, 2.933, 2.884, 2.837, 3.542e-05, 2.511, 2.344}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.515, 4.487, 4.46, 4.434, 4.371, 4.31, 4.252, 4.196, 4.142, 4.09, 4.04, 3.991, - 3.944, 3.898, 3.81, 3.727, 3.648, 3.573, 3.501, 3.433, 3.368, 3.305, 3.245, 3.187, 3.132, 3.079, 3.027, 2.977, 3.542e-05, 2.635, 2.459}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.722, 4.693, 4.665, 4.597, 4.532, 4.47, 4.411, 4.353, 4.298, 4.244, 4.193, - 4.143, 4.094, 4.001, 3.913, 3.83, 3.751, 3.675, 3.603, 3.534, 3.468, 3.405, 3.344, 3.286, 3.23, 3.176, 3.123, 3.542e-05, 2.763, 2.579}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.936, 4.906, 4.833, 4.764, 4.698, 4.635, 4.574, 4.515, 4.458, 4.403, - 4.35, 4.298, 4.2, 4.107, 4.019, 3.935, 3.856, 3.78, 3.707, 3.638, 3.571, 3.507, 3.446, 3.387, 3.33, 3.275, 3.542e-05, 2.896, 2.703}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.159, 5.081, 5.007, 4.936, 4.868, 4.803, 4.741, 4.681, 4.622, - 4.566, 4.512, 4.407, 4.309, 4.216, 4.128, 4.044, 3.964, 3.887, 3.814, 3.744, 3.677, 3.612, 3.55, 3.49, 3.432, 3.542e-05, 3.035, 2.832}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.75, 5.662, 5.579, 5.499, 5.423, 5.35, 5.28, 5.212, - 5.147, 5.084, 4.964, 4.851, 4.744, 4.643, 4.547, 4.456, 4.369, 4.286, 4.206, 4.13, 4.056, 3.986, 3.918, 3.853, 3.542e-05, 3.404, 3.176}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.395, 6.296, 6.202, 6.112, 6.027, 5.945, 5.866, - 5.79, 5.717, 5.579, 5.449, 5.327, 5.211, 5.102, 4.998, 4.898, 4.804, 4.714, 4.627, 4.544, 4.464, 4.388, 4.314, 3.542e-05, 3.808, 3.552}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.098, 6.985, 6.879, 6.779, 6.683, 6.591, - 6.503, 6.418, 6.258, 6.108, 5.968, 5.836, 5.711, 5.593, 5.48, 5.373, 5.27, 5.172, 5.078, 4.988, 4.902, 4.819, 3.542e-05, 4.25, 3.962}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.861, 7.734, 7.615, 7.502, 7.395, - 7.292, 7.193, 7.008, 6.835, 6.674, 6.523, 6.38, 6.245, 6.118, 5.996, 5.88, 5.769, 5.663, 5.561, 5.464, 5.37, 3.542e-05, 4.732, 4.410}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.69, 8.547, 8.413, 8.286, - 8.166, 8.051, 7.835, 7.636, 7.451, 7.278, 7.115, 6.961, 6.816, 6.678, 6.547, 6.421, 6.302, 6.187, 6.078, 5.972, 3.542e-05, 5.257, 4.897}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 9.588, 9.428, 9.277, - 9.135, 9.0, 8.749, 8.519, 8.305, 8.106, 7.92, 7.745, 7.58, 7.423, 7.275, 7.133, 6.998, 6.87, 6.746, 6.628, 3.542e-05, 5.827, 5.425}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.56, 10.38, - 10.21, 10.05, 9.759, 9.491, 9.244, 9.016, 8.803, 8.603, 8.415, 8.238, 8.069, 7.91, 7.758, 7.613, 7.474, 7.341, 3.542e-05, 6.445, 5.998}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 11.62, - 11.41, 11.22, 10.88, 10.56, 10.28, 10.01, 9.769, 9.541, 9.328, 9.126, 8.936, 8.756, 8.584, 8.421, 8.265, 8.116, 3.542e-05, 7.115, 6.618}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 12.75, 12.53, 12.11, 11.75, 11.41, 11.11, 10.83, 10.57, 10.32, 10.1, 9.88, 9.676, 9.483, 9.299, 9.124, 8.957, 3.542e-05, 7.84, 7.288}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 13.99, 13.49, 13.05, 12.67, 12.31, 11.99, 11.69, 11.41, 11.15, 10.91, 10.68, 10.46, 10.25, 10.06, 9.869, 3.542e-05, 8.623, 8.011}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 16.75, 16.12, 15.58, 15.1, 14.66, 14.26, 13.9, 13.56, 13.25, 12.95, 12.67, 12.41, 12.16, 11.93, 3.542e-05, 10.38, 9.628}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 19.97, 19.17, 18.49, 17.89, 17.36, 16.87, 16.43, 16.02, 15.64, 15.28, 14.95, 14.63, 14.34, 3.542e-05, 12.42, 11.5}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 23.71, 22.7, 21.85, 21.1, 20.45, 19.85, 19.31, 18.81, 18.35, 17.93, 17.53, 17.15, 3.542e-05, 14.77, 13.65}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 28.07, 26.78, 25.71, 24.79, 23.97, 23.25, 22.59, 21.99, 21.44, 20.93, 20.45, 3.542e-05, 17.48, 16.12}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 33.16, 31.5, 30.15, 29.0, 28.0, 27.11, 26.31, 25.59, 24.92, 24.31, 3.542e-05, 20.6, 18.94}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 39.13, 36.97, 35.25, 33.82, 32.58, 31.5, 30.53, 29.65, 28.86, 3.542e-05, 24.19, 22.16}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 46.17, 43.33, 41.13, 39.33, 37.8, 36.47, 35.29, 34.24, 3.542e-05, 28.31, 25.84}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 54.54, 50.75, 47.92, 45.65, 43.75, 42.11, 40.68, 3.542e-05, 33.07, 30.03}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 64.64, 59.47, 55.78, 52.9, 50.53, 48.51, 3.542e-05, 38.55, 34.81}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 77.05, 69.8, 64.93, 61.24, 58.27, 3.542e-05, 44.92, 40.28}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 92.76, 82.18, 75.63, 70.87, 3.542e-05, 52.35, 46.54}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 113.6, 97.22, 88.27, 3.542e-05, 61.12, 53.76}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 143.9, 115.8, 3.542e-05, 71.6, 62.15}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 201.8, 3.542e-05, 84.38, 71.99}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 148.4, 115.1}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 201.7, 144.2}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 270.9, 177.8}} - }; + DefaultSteamSuperheatedDensityDataTable = { + {{4.855e-03, 4.837e-03, 4.767e-03, 4.683e-03, 4.601e-03, 4.522e-03, 4.446e-03, 4.373e-03, 4.302e-03, 4.233e-03, 4.167e-03, 4.102e-03, + 4.039e-03, 3.979e-03, 3.920e-03, 3.863e-03, 3.840e-03, 3.818e-03, 3.796e-03, 3.775e-03, 3.753e-03, 3.732e-03, 3.711e-03, 3.691e-03, + 3.670e-03, 3.650e-03, 3.630e-03, 3.610e-03, 3.591e-03, 3.571e-03, 3.562e-03, 3.552e-03, 3.543e-03, 3.533e-03, 3.524e-03, 3.514e-03, + 3.505e-03, 3.496e-03, 3.487e-03, 3.477e-03, 3.468e-03, 3.459e-03, 3.450e-03, 3.441e-03, 3.432e-03, 3.424e-03, 3.415e-03, 3.406e-03, + 3.397e-03, 3.388e-03, 3.380e-03, 3.371e-03, 3.363e-03, 3.354e-03, 3.346e-03, 3.337e-03, 3.329e-03, 3.321e-03, 3.312e-03, 3.304e-03, + 3.296e-03, 3.288e-03, 3.271e-03, 3.255e-03, 3.239e-03, 3.224e-03, 3.208e-03, 3.193e-03, 3.177e-03, 3.162e-03, 3.147e-03, 3.132e-03, + 3.117e-03, 3.103e-03, 3.088e-03, 3.074e-03, 3.060e-03, 3.046e-03, 3.032e-03, 3.018e-03, 3.004e-03, 2.991e-03, 2.977e-03, 2.964e-03, + 2.951e-03, 2.938e-03, 2.925e-03, 2.893e-03, 2.862e-03, 2.831e-03, 2.801e-03, 2.772e-03, 2.743e-03, 2.715e-03, 2.688e-03, 2.661e-03, + 2.634e-03, 2.583e-03, 2.533e-03, 2.486e-03, 2.440e-03, 2.396e-03, 2.353e-03, 2.312e-03, 2.273e-03, 2.234e-03, 2.197e-03, 2.162e-03, + 2.127e-03, 2.093e-03, 2.061e-03, 3.542e-05, 1.833e-03, 1.714e-03}, + {0.0, 5.196e-03, 5.121e-03, 5.031e-03, 4.943e-03, 4.859e-03, 4.777e-03, 4.698e-03, 4.622e-03, 4.548e-03, 4.476e-03, 4.407e-03, + 4.340e-03, 4.274e-03, 4.211e-03, 4.150e-03, 4.126e-03, 4.102e-03, 4.078e-03, 4.055e-03, 4.032e-03, 4.009e-03, 3.987e-03, 3.965e-03, + 3.943e-03, 3.921e-03, 3.899e-03, 3.878e-03, 3.857e-03, 3.836e-03, 3.826e-03, 3.816e-03, 3.806e-03, 3.795e-03, 3.785e-03, 3.775e-03, + 3.765e-03, 3.755e-03, 3.746e-03, 3.736e-03, 3.726e-03, 3.716e-03, 3.707e-03, 3.697e-03, 3.687e-03, 3.678e-03, 3.668e-03, 3.659e-03, + 3.650e-03, 3.640e-03, 3.631e-03, 3.622e-03, 3.612e-03, 3.603e-03, 3.594e-03, 3.585e-03, 3.576e-03, 3.567e-03, 3.558e-03, 3.549e-03, + 3.541e-03, 3.532e-03, 3.514e-03, 3.497e-03, 3.480e-03, 3.463e-03, 3.446e-03, 3.430e-03, 3.413e-03, 3.397e-03, 3.381e-03, 3.365e-03, + 3.349e-03, 3.333e-03, 3.318e-03, 3.302e-03, 3.287e-03, 3.272e-03, 3.257e-03, 3.242e-03, 3.228e-03, 3.213e-03, 3.198e-03, 3.184e-03, + 3.170e-03, 3.156e-03, 3.142e-03, 3.108e-03, 3.074e-03, 3.041e-03, 3.009e-03, 2.978e-03, 2.947e-03, 2.917e-03, 2.887e-03, 2.858e-03, + 2.830e-03, 2.775e-03, 2.722e-03, 2.671e-03, 2.621e-03, 2.574e-03, 2.528e-03, 2.484e-03, 2.442e-03, 2.400e-03, 2.361e-03, 2.322e-03, + 2.285e-03, 2.249e-03, 2.214e-03, 3.542e-05, 1.969e-03, 1.841e-03}, + {0.0, 0.0, 6.802e-03, 6.681e-03, 6.565e-03, 6.453e-03, 6.344e-03, 6.239e-03, 6.138e-03, 6.040e-03, 5.944e-03, 5.852e-03, + 5.763e-03, 5.676e-03, 5.592e-03, 5.511e-03, 5.479e-03, 5.447e-03, 5.416e-03, 5.385e-03, 5.355e-03, 5.324e-03, 5.295e-03, 5.265e-03, + 5.236e-03, 5.207e-03, 5.178e-03, 5.150e-03, 5.122e-03, 5.095e-03, 5.081e-03, 5.067e-03, 5.054e-03, 5.040e-03, 5.027e-03, 5.014e-03, + 5.000e-03, 4.987e-03, 4.974e-03, 4.961e-03, 4.948e-03, 4.935e-03, 4.922e-03, 4.909e-03, 4.897e-03, 4.884e-03, 4.871e-03, 4.859e-03, + 4.846e-03, 4.834e-03, 4.822e-03, 4.809e-03, 4.797e-03, 4.785e-03, 4.773e-03, 4.761e-03, 4.749e-03, 4.737e-03, 4.725e-03, 4.714e-03, + 4.702e-03, 4.690e-03, 4.667e-03, 4.644e-03, 4.621e-03, 4.599e-03, 4.577e-03, 4.555e-03, 4.533e-03, 4.511e-03, 4.490e-03, 4.468e-03, + 4.447e-03, 4.427e-03, 4.406e-03, 4.385e-03, 4.365e-03, 4.345e-03, 4.325e-03, 4.306e-03, 4.286e-03, 4.267e-03, 4.247e-03, 4.228e-03, + 4.210e-03, 4.191e-03, 4.172e-03, 4.127e-03, 4.082e-03, 4.039e-03, 3.996e-03, 3.954e-03, 3.913e-03, 3.873e-03, 3.834e-03, 3.796e-03, + 3.758e-03, 3.685e-03, 3.614e-03, 3.546e-03, 3.481e-03, 3.418e-03, 3.357e-03, 3.299e-03, 3.242e-03, 3.188e-03, 3.135e-03, 3.084e-03, + 3.034e-03, 2.986e-03, 2.940e-03, 3.542e-05, 2.615e-03, 2.445e-03}, + {0.0, 0.0, 0.0, 9.407e-03, 9.243e-03, 9.084e-03, 8.931e-03, 8.783e-03, 8.640e-03, 8.502e-03, 8.368e-03, 8.238e-03, + 8.113e-03, 7.991e-03, 7.872e-03, 7.757e-03, 7.712e-03, 7.668e-03, 7.624e-03, 7.580e-03, 7.537e-03, 7.495e-03, 7.453e-03, 7.411e-03, + 7.370e-03, 7.330e-03, 7.289e-03, 7.250e-03, 7.210e-03, 7.172e-03, 7.152e-03, 7.133e-03, 7.114e-03, 7.095e-03, 7.076e-03, 7.057e-03, + 7.039e-03, 7.020e-03, 7.002e-03, 6.983e-03, 6.965e-03, 6.947e-03, 6.929e-03, 6.911e-03, 6.893e-03, 6.875e-03, 6.857e-03, 6.840e-03, + 6.822e-03, 6.805e-03, 6.787e-03, 6.770e-03, 6.753e-03, 6.736e-03, 6.719e-03, 6.702e-03, 6.685e-03, 6.668e-03, 6.651e-03, 6.635e-03, + 6.618e-03, 6.602e-03, 6.569e-03, 6.537e-03, 6.505e-03, 6.473e-03, 6.442e-03, 6.411e-03, 6.380e-03, 6.350e-03, 6.320e-03, 6.290e-03, + 6.260e-03, 6.231e-03, 6.202e-03, 6.173e-03, 6.144e-03, 6.116e-03, 6.088e-03, 6.060e-03, 6.033e-03, 6.006e-03, 5.979e-03, 5.952e-03, + 5.925e-03, 5.899e-03, 5.873e-03, 5.809e-03, 5.746e-03, 5.685e-03, 5.625e-03, 5.566e-03, 5.508e-03, 5.452e-03, 5.397e-03, 5.342e-03, + 5.289e-03, 5.186e-03, 5.087e-03, 4.992e-03, 4.900e-03, 4.811e-03, 4.726e-03, 4.643e-03, 4.564e-03, 4.487e-03, 4.412e-03, 4.340e-03, + 4.271e-03, 4.203e-03, 4.138e-03, 3.542e-05, 3.680e-03, 3.442e-03}, + {0.0, 0.0, 0.0, 0.0, 1.284e-02, 1.262e-02, 1.241e-02, 1.220e-02, 1.200e-02, 1.181e-02, 1.162e-02, 1.144e-02, + 1.127e-02, 1.110e-02, 1.093e-02, 1.078e-02, 1.071e-02, 1.065e-02, 1.059e-02, 1.053e-02, 1.047e-02, 1.041e-02, 1.035e-02, 1.029e-02, + 1.024e-02, 1.018e-02, 1.012e-02, 1.007e-02, 1.001e-02, 9.961e-03, 9.934e-03, 9.907e-03, 9.881e-03, 9.855e-03, 9.828e-03, 9.802e-03, + 9.776e-03, 9.750e-03, 9.725e-03, 9.699e-03, 9.674e-03, 9.649e-03, 9.623e-03, 9.598e-03, 9.574e-03, 9.549e-03, 9.524e-03, 9.500e-03, + 9.475e-03, 9.451e-03, 9.427e-03, 9.403e-03, 9.379e-03, 9.355e-03, 9.332e-03, 9.308e-03, 9.285e-03, 9.261e-03, 9.238e-03, 9.215e-03, + 9.192e-03, 9.170e-03, 9.124e-03, 9.079e-03, 9.035e-03, 8.991e-03, 8.947e-03, 8.904e-03, 8.862e-03, 8.819e-03, 8.777e-03, 8.736e-03, + 8.695e-03, 8.654e-03, 8.614e-03, 8.574e-03, 8.534e-03, 8.495e-03, 8.456e-03, 8.417e-03, 8.379e-03, 8.341e-03, 8.304e-03, 8.267e-03, + 8.230e-03, 8.193e-03, 8.157e-03, 8.068e-03, 7.981e-03, 7.896e-03, 7.812e-03, 7.731e-03, 7.651e-03, 7.572e-03, 7.495e-03, 7.420e-03, + 7.346e-03, 7.203e-03, 7.065e-03, 6.933e-03, 6.805e-03, 6.682e-03, 6.563e-03, 6.449e-03, 6.338e-03, 6.231e-03, 6.128e-03, 6.028e-03, + 5.931e-03, 5.838e-03, 5.747e-03, 3.542e-05, 5.111e-03, 4.781e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 1.731e-02, 1.702e-02, 1.674e-02, 1.646e-02, 1.620e-02, 1.594e-02, 1.570e-02, + 1.546e-02, 1.522e-02, 1.500e-02, 1.478e-02, 1.469e-02, 1.461e-02, 1.452e-02, 1.444e-02, 1.436e-02, 1.428e-02, 1.420e-02, 1.412e-02, + 1.404e-02, 1.396e-02, 1.389e-02, 1.381e-02, 1.374e-02, 1.366e-02, 1.362e-02, 1.359e-02, 1.355e-02, 1.352e-02, 1.348e-02, 1.344e-02, + 1.341e-02, 1.337e-02, 1.334e-02, 1.330e-02, 1.327e-02, 1.323e-02, 1.320e-02, 1.316e-02, 1.313e-02, 1.310e-02, 1.306e-02, 1.303e-02, + 1.300e-02, 1.296e-02, 1.293e-02, 1.290e-02, 1.286e-02, 1.283e-02, 1.280e-02, 1.277e-02, 1.273e-02, 1.270e-02, 1.267e-02, 1.264e-02, + 1.261e-02, 1.258e-02, 1.251e-02, 1.245e-02, 1.239e-02, 1.233e-02, 1.227e-02, 1.221e-02, 1.215e-02, 1.210e-02, 1.204e-02, 1.198e-02, + 1.192e-02, 1.187e-02, 1.181e-02, 1.176e-02, 1.170e-02, 1.165e-02, 1.160e-02, 1.154e-02, 1.149e-02, 1.144e-02, 1.139e-02, 1.134e-02, + 1.129e-02, 1.124e-02, 1.119e-02, 1.107e-02, 1.095e-02, 1.083e-02, 1.071e-02, 1.060e-02, 1.049e-02, 1.038e-02, 1.028e-02, 1.018e-02, + 1.007e-02, 9.879e-03, 9.690e-03, 9.508e-03, 9.333e-03, 9.164e-03, 9.001e-03, 8.844e-03, 8.692e-03, 8.546e-03, 8.404e-03, 8.267e-03, + 8.134e-03, 8.006e-03, 7.881e-03, 3.542e-05, 7.009e-03, 6.556e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.307e-02, 2.269e-02, 2.232e-02, 2.196e-02, 2.161e-02, 2.128e-02, + 2.095e-02, 2.063e-02, 2.033e-02, 2.003e-02, 1.991e-02, 1.980e-02, 1.968e-02, 1.957e-02, 1.946e-02, 1.935e-02, 1.924e-02, 1.913e-02, + 1.903e-02, 1.892e-02, 1.882e-02, 1.872e-02, 1.862e-02, 1.851e-02, 1.846e-02, 1.842e-02, 1.837e-02, 1.832e-02, 1.827e-02, 1.822e-02, + 1.817e-02, 1.812e-02, 1.808e-02, 1.803e-02, 1.798e-02, 1.793e-02, 1.789e-02, 1.784e-02, 1.779e-02, 1.775e-02, 1.770e-02, 1.766e-02, + 1.761e-02, 1.757e-02, 1.752e-02, 1.748e-02, 1.743e-02, 1.739e-02, 1.734e-02, 1.730e-02, 1.726e-02, 1.721e-02, 1.717e-02, 1.713e-02, + 1.708e-02, 1.704e-02, 1.696e-02, 1.687e-02, 1.679e-02, 1.671e-02, 1.663e-02, 1.655e-02, 1.647e-02, 1.639e-02, 1.631e-02, 1.624e-02, + 1.616e-02, 1.608e-02, 1.601e-02, 1.593e-02, 1.586e-02, 1.579e-02, 1.572e-02, 1.564e-02, 1.557e-02, 1.550e-02, 1.543e-02, 1.536e-02, + 1.530e-02, 1.523e-02, 1.516e-02, 1.499e-02, 1.483e-02, 1.467e-02, 1.452e-02, 1.437e-02, 1.422e-02, 1.407e-02, 1.393e-02, 1.379e-02, + 1.365e-02, 1.339e-02, 1.313e-02, 1.288e-02, 1.265e-02, 1.242e-02, 1.220e-02, 1.198e-02, 1.178e-02, 1.158e-02, 1.139e-02, 1.120e-02, + 1.102e-02, 1.085e-02, 1.068e-02, 3.542e-05, 9.498e-03, 8.884e-03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.042e-02, 2.992e-02, 2.943e-02, 2.897e-02, 2.851e-02, + 2.808e-02, 2.765e-02, 2.724e-02, 2.684e-02, 2.669e-02, 2.653e-02, 2.638e-02, 2.623e-02, 2.608e-02, 2.593e-02, 2.579e-02, 2.564e-02, + 2.550e-02, 2.536e-02, 2.522e-02, 2.508e-02, 2.494e-02, 2.481e-02, 2.474e-02, 2.468e-02, 2.461e-02, 2.454e-02, 2.448e-02, 2.441e-02, + 2.435e-02, 2.428e-02, 2.422e-02, 2.416e-02, 2.409e-02, 2.403e-02, 2.397e-02, 2.391e-02, 2.384e-02, 2.378e-02, 2.372e-02, 2.366e-02, + 2.360e-02, 2.354e-02, 2.348e-02, 2.342e-02, 2.336e-02, 2.330e-02, 2.324e-02, 2.318e-02, 2.312e-02, 2.306e-02, 2.301e-02, 2.295e-02, + 2.289e-02, 2.284e-02, 2.272e-02, 2.261e-02, 2.250e-02, 2.239e-02, 2.228e-02, 2.217e-02, 2.207e-02, 2.196e-02, 2.186e-02, 2.175e-02, + 2.165e-02, 2.155e-02, 2.145e-02, 2.135e-02, 2.125e-02, 2.115e-02, 2.106e-02, 2.096e-02, 2.087e-02, 2.077e-02, 2.068e-02, 2.059e-02, + 2.049e-02, 2.040e-02, 2.031e-02, 2.009e-02, 1.987e-02, 1.966e-02, 1.945e-02, 1.925e-02, 1.905e-02, 1.885e-02, 1.866e-02, 1.848e-02, + 1.829e-02, 1.794e-02, 1.759e-02, 1.726e-02, 1.694e-02, 1.664e-02, 1.634e-02, 1.606e-02, 1.578e-02, 1.552e-02, 1.526e-02, 1.501e-02, + 1.477e-02, 1.453e-02, 1.431e-02, 3.542e-05, 1.273e-02, 1.190e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.967e-02, 3.903e-02, 3.841e-02, 3.781e-02, + 3.723e-02, 3.666e-02, 3.612e-02, 3.559e-02, 3.538e-02, 3.518e-02, 3.497e-02, 3.477e-02, 3.457e-02, 3.438e-02, 3.419e-02, 3.399e-02, + 3.380e-02, 3.362e-02, 3.343e-02, 3.325e-02, 3.307e-02, 3.289e-02, 3.280e-02, 3.271e-02, 3.262e-02, 3.254e-02, 3.245e-02, 3.236e-02, + 3.228e-02, 3.219e-02, 3.211e-02, 3.202e-02, 3.194e-02, 3.186e-02, 3.177e-02, 3.169e-02, 3.161e-02, 3.153e-02, 3.144e-02, 3.136e-02, + 3.128e-02, 3.120e-02, 3.112e-02, 3.104e-02, 3.096e-02, 3.089e-02, 3.081e-02, 3.073e-02, 3.065e-02, 3.058e-02, 3.050e-02, 3.042e-02, + 3.035e-02, 3.027e-02, 3.012e-02, 2.997e-02, 2.983e-02, 2.968e-02, 2.954e-02, 2.939e-02, 2.925e-02, 2.911e-02, 2.897e-02, 2.884e-02, + 2.870e-02, 2.857e-02, 2.843e-02, 2.830e-02, 2.817e-02, 2.804e-02, 2.791e-02, 2.778e-02, 2.766e-02, 2.753e-02, 2.741e-02, 2.729e-02, + 2.716e-02, 2.704e-02, 2.692e-02, 2.663e-02, 2.634e-02, 2.606e-02, 2.579e-02, 2.552e-02, 2.525e-02, 2.499e-02, 2.474e-02, 2.449e-02, + 2.425e-02, 2.377e-02, 2.332e-02, 2.288e-02, 2.246e-02, 2.205e-02, 2.166e-02, 2.128e-02, 2.092e-02, 2.057e-02, 2.022e-02, 1.989e-02, + 1.957e-02, 1.927e-02, 1.897e-02, 3.542e-05, 1.687e-02, 1.578e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.124e-02, 5.042e-02, 4.963e-02, + 4.887e-02, 4.812e-02, 4.741e-02, 4.671e-02, 4.644e-02, 4.617e-02, 4.590e-02, 4.564e-02, 4.537e-02, 4.512e-02, 4.486e-02, 4.461e-02, + 4.436e-02, 4.412e-02, 4.387e-02, 4.363e-02, 4.340e-02, 4.316e-02, 4.304e-02, 4.293e-02, 4.281e-02, 4.270e-02, 4.258e-02, 4.247e-02, + 4.236e-02, 4.225e-02, 4.213e-02, 4.202e-02, 4.191e-02, 4.180e-02, 4.169e-02, 4.158e-02, 4.148e-02, 4.137e-02, 4.126e-02, 4.116e-02, + 4.105e-02, 4.094e-02, 4.084e-02, 4.073e-02, 4.063e-02, 4.053e-02, 4.043e-02, 4.032e-02, 4.022e-02, 4.012e-02, 4.002e-02, 3.992e-02, + 3.982e-02, 3.972e-02, 3.952e-02, 3.933e-02, 3.914e-02, 3.895e-02, 3.876e-02, 3.857e-02, 3.838e-02, 3.820e-02, 3.802e-02, 3.784e-02, + 3.766e-02, 3.748e-02, 3.731e-02, 3.713e-02, 3.696e-02, 3.679e-02, 3.662e-02, 3.646e-02, 3.629e-02, 3.613e-02, 3.596e-02, 3.580e-02, + 3.564e-02, 3.548e-02, 3.533e-02, 3.494e-02, 3.456e-02, 3.419e-02, 3.383e-02, 3.348e-02, 3.313e-02, 3.279e-02, 3.246e-02, 3.213e-02, + 3.181e-02, 3.119e-02, 3.059e-02, 3.002e-02, 2.947e-02, 2.893e-02, 2.842e-02, 2.792e-02, 2.744e-02, 2.698e-02, 2.653e-02, 2.610e-02, + 2.568e-02, 2.528e-02, 2.488e-02, 3.542e-05, 2.213e-02, 2.070e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.556e-02, 6.453e-02, + 6.353e-02, 6.256e-02, 6.163e-02, 6.072e-02, 6.036e-02, 6.001e-02, 5.966e-02, 5.932e-02, 5.898e-02, 5.864e-02, 5.831e-02, 5.799e-02, + 5.766e-02, 5.734e-02, 5.702e-02, 5.671e-02, 5.640e-02, 5.610e-02, 5.594e-02, 5.579e-02, 5.564e-02, 5.549e-02, 5.535e-02, 5.520e-02, + 5.505e-02, 5.490e-02, 5.476e-02, 5.461e-02, 5.447e-02, 5.433e-02, 5.419e-02, 5.404e-02, 5.390e-02, 5.376e-02, 5.362e-02, 5.349e-02, + 5.335e-02, 5.321e-02, 5.307e-02, 5.294e-02, 5.280e-02, 5.267e-02, 5.254e-02, 5.240e-02, 5.227e-02, 5.214e-02, 5.201e-02, 5.188e-02, + 5.175e-02, 5.162e-02, 5.136e-02, 5.111e-02, 5.086e-02, 5.061e-02, 5.036e-02, 5.012e-02, 4.988e-02, 4.964e-02, 4.940e-02, 4.917e-02, + 4.894e-02, 4.871e-02, 4.848e-02, 4.825e-02, 4.803e-02, 4.781e-02, 4.759e-02, 4.737e-02, 4.716e-02, 4.694e-02, 4.673e-02, 4.652e-02, + 4.632e-02, 4.611e-02, 4.591e-02, 4.540e-02, 4.491e-02, 4.443e-02, 4.396e-02, 4.350e-02, 4.305e-02, 4.261e-02, 4.218e-02, 4.175e-02, + 4.134e-02, 4.053e-02, 3.975e-02, 3.901e-02, 3.829e-02, 3.759e-02, 3.693e-02, 3.628e-02, 3.566e-02, 3.506e-02, 3.448e-02, 3.391e-02, + 3.337e-02, 3.284e-02, 3.233e-02, 3.542e-05, 2.875e-02, 2.689e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.315e-02, + 8.185e-02, 8.060e-02, 7.939e-02, 7.821e-02, 7.775e-02, 7.730e-02, 7.685e-02, 7.641e-02, 7.597e-02, 7.553e-02, 7.511e-02, 7.468e-02, + 7.426e-02, 7.385e-02, 7.344e-02, 7.304e-02, 7.264e-02, 7.224e-02, 7.205e-02, 7.185e-02, 7.166e-02, 7.147e-02, 7.128e-02, 7.108e-02, + 7.090e-02, 7.071e-02, 7.052e-02, 7.033e-02, 7.015e-02, 6.996e-02, 6.978e-02, 6.960e-02, 6.942e-02, 6.923e-02, 6.906e-02, 6.888e-02, + 6.870e-02, 6.852e-02, 6.835e-02, 6.817e-02, 6.800e-02, 6.782e-02, 6.765e-02, 6.748e-02, 6.731e-02, 6.714e-02, 6.697e-02, 6.680e-02, + 6.664e-02, 6.647e-02, 6.614e-02, 6.581e-02, 6.549e-02, 6.517e-02, 6.485e-02, 6.454e-02, 6.423e-02, 6.392e-02, 6.361e-02, 6.331e-02, + 6.301e-02, 6.272e-02, 6.242e-02, 6.213e-02, 6.185e-02, 6.156e-02, 6.128e-02, 6.100e-02, 6.072e-02, 6.044e-02, 6.017e-02, 5.990e-02, + 5.963e-02, 5.937e-02, 5.911e-02, 5.846e-02, 5.783e-02, 5.721e-02, 5.660e-02, 5.601e-02, 5.543e-02, 5.486e-02, 5.430e-02, 5.375e-02, + 5.322e-02, 5.218e-02, 5.118e-02, 5.022e-02, 4.929e-02, 4.840e-02, 4.754e-02, 4.671e-02, 4.591e-02, 4.513e-02, 4.438e-02, 4.366e-02, + 4.296e-02, 4.228e-02, 4.162e-02, 3.542e-05, 3.701e-02, 3.462e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.10460, 0.10290, 0.10140, 9.988e-02, 9.929e-02, 9.871e-02, 9.813e-02, 9.757e-02, 9.700e-02, 9.645e-02, 9.590e-02, 9.536e-02, + 9.482e-02, 9.430e-02, 9.377e-02, 9.325e-02, 9.274e-02, 9.224e-02, 9.199e-02, 9.174e-02, 9.149e-02, 9.124e-02, 9.100e-02, 9.075e-02, + 9.051e-02, 9.027e-02, 9.003e-02, 8.979e-02, 8.955e-02, 8.932e-02, 8.908e-02, 8.885e-02, 8.862e-02, 8.839e-02, 8.816e-02, 8.793e-02, + 8.770e-02, 8.747e-02, 8.725e-02, 8.703e-02, 8.680e-02, 8.658e-02, 8.636e-02, 8.614e-02, 8.592e-02, 8.571e-02, 8.549e-02, 8.528e-02, + 8.506e-02, 8.485e-02, 8.443e-02, 8.401e-02, 8.360e-02, 8.319e-02, 8.278e-02, 8.238e-02, 8.198e-02, 8.159e-02, 8.120e-02, 8.081e-02, + 8.043e-02, 8.005e-02, 7.968e-02, 7.931e-02, 7.894e-02, 7.857e-02, 7.821e-02, 7.786e-02, 7.750e-02, 7.715e-02, 7.680e-02, 7.646e-02, + 7.611e-02, 7.578e-02, 7.544e-02, 7.461e-02, 7.380e-02, 7.301e-02, 7.224e-02, 7.148e-02, 7.074e-02, 7.001e-02, 6.930e-02, 6.860e-02, + 6.792e-02, 6.659e-02, 6.532e-02, 6.409e-02, 6.291e-02, 6.177e-02, 6.067e-02, 5.961e-02, 5.859e-02, 5.760e-02, 5.664e-02, 5.572e-02, + 5.482e-02, 5.395e-02, 5.312e-02, 3.542e-05, 4.724e-02, 4.418e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.13040, 0.12840, 0.12650, 0.12580, 0.125, 0.12430, 0.12360, 0.12290, 0.12220, 0.12150, 0.12080, + 0.12010, 0.11940, 0.11870, 0.11810, 0.11740, 0.11680, 0.11650, 0.11620, 0.11580, 0.11550, 0.11520, 0.11490, + 0.11460, 0.11430, 0.114, 0.11370, 0.11340, 0.11310, 0.11280, 0.11250, 0.11220, 0.11190, 0.11160, 0.11130, + 0.111, 0.11080, 0.11050, 0.11020, 0.10990, 0.10960, 0.10930, 0.10910, 0.10880, 0.10850, 0.10820, 0.108, + 0.10770, 0.10740, 0.10690, 0.10640, 0.10580, 0.10530, 0.10480, 0.10430, 0.10380, 0.10330, 0.10280, 0.10230, + 0.10180, 0.10130, 0.10090, 0.10040, 9.993e-02, 9.946e-02, 9.901e-02, 9.855e-02, 9.810e-02, 9.766e-02, 9.722e-02, 9.678e-02, + 9.635e-02, 9.592e-02, 9.549e-02, 9.444e-02, 9.342e-02, 9.242e-02, 9.144e-02, 9.048e-02, 8.954e-02, 8.862e-02, 8.771e-02, 8.683e-02, + 8.597e-02, 8.429e-02, 8.267e-02, 8.112e-02, 7.962e-02, 7.818e-02, 7.678e-02, 7.544e-02, 7.415e-02, 7.289e-02, 7.168e-02, 7.051e-02, + 6.938e-02, 6.828e-02, 6.722e-02, 3.542e-05, 5.978e-02, 5.591e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.16150, 0.159, 0.15810, 0.15710, 0.15620, 0.15530, 0.15440, 0.15350, 0.15260, 0.15180, + 0.15090, 0.15, 0.14920, 0.14840, 0.14760, 0.14670, 0.14630, 0.14590, 0.14550, 0.14520, 0.14480, 0.14440, + 0.144, 0.14360, 0.14320, 0.14280, 0.14250, 0.14210, 0.14170, 0.14130, 0.141, 0.14060, 0.14020, 0.13990, + 0.13950, 0.13910, 0.13880, 0.13840, 0.13810, 0.13770, 0.13730, 0.137, 0.13660, 0.13630, 0.136, 0.13560, + 0.13530, 0.13490, 0.13430, 0.13360, 0.13290, 0.13230, 0.13160, 0.131, 0.13040, 0.12970, 0.12910, 0.12850, + 0.12790, 0.12730, 0.12670, 0.12610, 0.12550, 0.12490, 0.12430, 0.12380, 0.12320, 0.12260, 0.12210, 0.12150, + 0.121, 0.12050, 0.11990, 0.11860, 0.11730, 0.11610, 0.11480, 0.11360, 0.11240, 0.11130, 0.11010, 0.109, + 0.10790, 0.10580, 0.10380, 0.10190, 9.997e-02, 9.816e-02, 9.641e-02, 9.473e-02, 9.310e-02, 9.152e-02, 9.000e-02, 8.853e-02, + 8.711e-02, 8.573e-02, 8.440e-02, 3.542e-05, 7.505e-02, 7.019e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.19840, 0.19720, 0.19610, 0.19490, 0.19370, 0.19260, 0.19150, 0.19040, 0.18930, 0.18820, 0.18720, + 0.18610, 0.18510, 0.184, 0.183, 0.18250, 0.182, 0.18150, 0.181, 0.18050, 0.18, 0.17960, 0.17910, 0.17860, + 0.17810, 0.17760, 0.17720, 0.17670, 0.17620, 0.17580, 0.17530, 0.17480, 0.17440, 0.17390, 0.17350, 0.173, 0.17260, + 0.17210, 0.17170, 0.17120, 0.17080, 0.17040, 0.16990, 0.16950, 0.16910, 0.16870, 0.16820, 0.16740, 0.16660, 0.16570, + 0.16490, 0.16410, 0.16330, 0.16250, 0.16170, 0.16090, 0.16020, 0.15940, 0.15870, 0.15790, 0.15720, 0.15640, 0.15570, + 0.155, 0.15430, 0.15360, 0.15290, 0.15220, 0.15150, 0.15080, 0.15010, 0.14950, 0.14780, 0.14620, 0.14460, 0.14310, + 0.14160, 0.14010, 0.13870, 0.13730, 0.13590, 0.13450, 0.13190, 0.12940, 0.12690, 0.12460, 0.12230, 0.12010, 0.118, + 0.116, 0.11410, 0.11220, 0.11030, 0.10850, 0.10680, 0.10520, 3.542e-05, 9.352e-02, 8.746e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.21510, 0.21380, 0.21250, 0.21130, 0.21, 0.20880, 0.20760, 0.20640, 0.20520, 0.204, + 0.20290, 0.20180, 0.20060, 0.19950, 0.199, 0.19840, 0.19790, 0.19730, 0.19680, 0.19630, 0.19570, 0.19520, 0.19470, + 0.19420, 0.19360, 0.19310, 0.19260, 0.19210, 0.19160, 0.19110, 0.19060, 0.19010, 0.18960, 0.18910, 0.18860, 0.18810, + 0.18760, 0.18720, 0.18670, 0.18620, 0.18570, 0.18520, 0.18480, 0.18430, 0.18380, 0.18340, 0.18250, 0.18150, 0.18060, + 0.17980, 0.17890, 0.178, 0.17710, 0.17630, 0.17540, 0.17460, 0.17380, 0.17290, 0.17210, 0.17130, 0.17050, 0.16970, + 0.16890, 0.16820, 0.16740, 0.16660, 0.16590, 0.16510, 0.16440, 0.16360, 0.16290, 0.16110, 0.15940, 0.15770, 0.156, + 0.15430, 0.15270, 0.15110, 0.14960, 0.14810, 0.14660, 0.14370, 0.141, 0.13830, 0.13580, 0.13330, 0.13090, 0.12860, + 0.12640, 0.12430, 0.12220, 0.12020, 0.11830, 0.11640, 0.11460, 3.542e-05, 0.10190, 9.531e-02}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.23290, 0.23150, 0.23010, 0.22870, 0.22740, 0.22610, 0.22480, 0.22350, 0.22220, 0.221, 0.21970, 0.21850, 0.21730, + 0.21670, 0.21610, 0.21550, 0.21490, 0.21430, 0.21370, 0.21310, 0.21260, 0.212, 0.21140, 0.21090, 0.21030, 0.20970, 0.20920, 0.20860, + 0.20810, 0.20750, 0.207, 0.20640, 0.20590, 0.20540, 0.20480, 0.20430, 0.20380, 0.20330, 0.20270, 0.20220, 0.20170, 0.20120, 0.20070, + 0.20020, 0.19970, 0.19870, 0.19770, 0.19670, 0.19570, 0.19480, 0.19380, 0.19290, 0.19190, 0.191, 0.19010, 0.18920, 0.18830, 0.18740, + 0.18650, 0.18560, 0.18480, 0.18390, 0.18310, 0.18220, 0.18140, 0.18060, 0.17980, 0.179, 0.17820, 0.17740, 0.17540, 0.17350, 0.17160, + 0.16980, 0.168, 0.16630, 0.16450, 0.16290, 0.16120, 0.15960, 0.15650, 0.15350, 0.15060, 0.14780, 0.14510, 0.14250, 0.14, 0.13760, + 0.13530, 0.133, 0.13090, 0.12880, 0.12670, 0.12480, 3.542e-05, 0.11090, 0.1037}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.25180, 0.25030, 0.24890, 0.24740, 0.246, 0.24450, 0.24310, 0.24170, 0.24040, 0.239, 0.23770, 0.23640, + 0.23570, 0.23510, 0.23440, 0.23380, 0.23310, 0.23250, 0.23190, 0.23120, 0.23060, 0.23, 0.22940, 0.22880, 0.22810, 0.22750, 0.22690, + 0.22630, 0.22570, 0.22510, 0.22460, 0.224, 0.22340, 0.22280, 0.22220, 0.22160, 0.22110, 0.22050, 0.21990, 0.21940, 0.21880, 0.21830, + 0.21770, 0.21720, 0.21610, 0.215, 0.21390, 0.21290, 0.21180, 0.21080, 0.20970, 0.20870, 0.20770, 0.20670, 0.20570, 0.20480, 0.20380, + 0.20280, 0.20190, 0.201, 0.2, 0.19910, 0.19820, 0.19730, 0.19640, 0.19550, 0.19460, 0.19370, 0.19290, 0.19080, 0.18870, 0.18660, + 0.18470, 0.18270, 0.18080, 0.17890, 0.17710, 0.17530, 0.17360, 0.17020, 0.16690, 0.16370, 0.16070, 0.15780, 0.155, 0.15230, 0.14960, + 0.14710, 0.14470, 0.14230, 0.14, 0.13780, 0.13560, 3.542e-05, 0.12060, 0.1128}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.27210, 0.27050, 0.26890, 0.26730, 0.26580, 0.26420, 0.26270, 0.26120, 0.25970, 0.25830, 0.25680, + 0.25610, 0.25540, 0.25470, 0.254, 0.25330, 0.25260, 0.25190, 0.25130, 0.25060, 0.24990, 0.24920, 0.24860, 0.24790, 0.24720, 0.24660, + 0.24590, 0.24530, 0.24460, 0.244, 0.24330, 0.24270, 0.24210, 0.24140, 0.24080, 0.24020, 0.23960, 0.239, 0.23840, 0.23770, 0.23710, + 0.23650, 0.23590, 0.23480, 0.23360, 0.23240, 0.23130, 0.23010, 0.229, 0.22790, 0.22680, 0.22570, 0.22460, 0.22350, 0.22250, 0.22140, + 0.22040, 0.21930, 0.21830, 0.21730, 0.21630, 0.21530, 0.21430, 0.21330, 0.21240, 0.21140, 0.21050, 0.20950, 0.20720, 0.205, 0.20270, + 0.20060, 0.19850, 0.19640, 0.19440, 0.19240, 0.19040, 0.18850, 0.18480, 0.18130, 0.17790, 0.17460, 0.17140, 0.16830, 0.16540, 0.16250, + 0.15980, 0.15710, 0.15460, 0.15210, 0.14970, 0.14730, 3.542e-05, 0.131, 0.1225}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.29370, 0.29190, 0.29020, 0.28850, 0.28690, 0.28520, 0.28360, 0.282, 0.28040, 0.27880, + 0.278, 0.27730, 0.27650, 0.27570, 0.275, 0.27420, 0.27350, 0.27270, 0.272, 0.27130, 0.27050, 0.26980, 0.26910, 0.26840, 0.26760, + 0.26690, 0.26620, 0.26550, 0.26480, 0.26410, 0.26340, 0.26280, 0.26210, 0.26140, 0.26070, 0.26, 0.25940, 0.25870, 0.258, 0.25740, + 0.25670, 0.25610, 0.25480, 0.25350, 0.25220, 0.251, 0.24980, 0.24850, 0.24730, 0.24610, 0.24490, 0.24370, 0.24260, 0.24140, 0.24030, + 0.23910, 0.238, 0.23690, 0.23580, 0.23470, 0.23360, 0.23260, 0.23150, 0.23050, 0.22940, 0.22840, 0.22740, 0.22490, 0.22240, 0.22, + 0.21770, 0.21540, 0.21310, 0.21090, 0.20880, 0.20660, 0.20460, 0.20060, 0.19670, 0.193, 0.18940, 0.186, 0.18270, 0.17950, 0.17640, + 0.17340, 0.17050, 0.16770, 0.165, 0.16240, 0.15990, 3.542e-05, 0.14210, 0.1329}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31660, 0.31480, 0.31290, 0.31110, 0.30930, 0.30760, 0.30580, 0.30410, 0.30240, + 0.30150, 0.30070, 0.29990, 0.299, 0.29820, 0.29740, 0.29660, 0.29580, 0.295, 0.29420, 0.29340, 0.29260, 0.29180, 0.291, 0.29020, + 0.28940, 0.28870, 0.28790, 0.28720, 0.28640, 0.28560, 0.28490, 0.28420, 0.28340, 0.28270, 0.282, 0.28120, 0.28050, 0.27980, 0.27910, + 0.27840, 0.27760, 0.27620, 0.27490, 0.27350, 0.27210, 0.27080, 0.26940, 0.26810, 0.26680, 0.26550, 0.26430, 0.263, 0.26170, 0.26050, + 0.25930, 0.258, 0.25680, 0.25560, 0.25450, 0.25330, 0.25210, 0.251, 0.24980, 0.24870, 0.24760, 0.24650, 0.24380, 0.24110, 0.23850, + 0.23590, 0.23350, 0.231, 0.22860, 0.22630, 0.224, 0.22170, 0.21740, 0.21320, 0.20920, 0.20530, 0.20160, 0.198, 0.19450, 0.19120, + 0.18790, 0.18480, 0.18180, 0.17880, 0.176, 0.17330, 3.542e-05, 0.154, 0.1441}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.34110, 0.33910, 0.33710, 0.33520, 0.33320, 0.33130, 0.32940, 0.32760, + 0.32670, 0.32580, 0.32490, 0.324, 0.32310, 0.32220, 0.32130, 0.32040, 0.31950, 0.31870, 0.31780, 0.31690, 0.31610, 0.31520, 0.31440, + 0.31350, 0.31270, 0.31190, 0.31110, 0.31020, 0.30940, 0.30860, 0.30780, 0.307, 0.30620, 0.30540, 0.30460, 0.30380, 0.30310, 0.30230, + 0.30150, 0.30070, 0.29920, 0.29770, 0.29620, 0.29470, 0.29330, 0.29180, 0.29040, 0.289, 0.28760, 0.28620, 0.28480, 0.28350, 0.28210, + 0.28080, 0.27950, 0.27820, 0.27690, 0.27560, 0.27430, 0.27310, 0.27180, 0.27060, 0.26930, 0.26810, 0.26690, 0.264, 0.26110, 0.25830, + 0.25550, 0.25280, 0.25020, 0.24760, 0.245, 0.24260, 0.24010, 0.23540, 0.23090, 0.22650, 0.22230, 0.21830, 0.21440, 0.21060, 0.207, + 0.20350, 0.20010, 0.19680, 0.19360, 0.19060, 0.18760, 3.542e-05, 0.16680, 0.156}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.36710, 0.36490, 0.36280, 0.36070, 0.35860, 0.35660, 0.35460, + 0.35360, 0.35260, 0.35160, 0.35060, 0.34960, 0.34870, 0.34770, 0.34680, 0.34580, 0.34490, 0.34390, 0.343, 0.34210, 0.34110, 0.34020, + 0.33930, 0.33840, 0.33750, 0.33660, 0.33570, 0.33480, 0.334, 0.33310, 0.33220, 0.33130, 0.33050, 0.32960, 0.32880, 0.32790, 0.32710, + 0.32630, 0.32540, 0.32380, 0.32210, 0.32050, 0.31890, 0.31730, 0.31580, 0.31420, 0.31270, 0.31120, 0.30970, 0.30820, 0.30670, 0.30520, + 0.30380, 0.30240, 0.30090, 0.29950, 0.29820, 0.29680, 0.29540, 0.29410, 0.29270, 0.29140, 0.29010, 0.28880, 0.28560, 0.28250, 0.27940, + 0.27640, 0.27350, 0.27060, 0.26780, 0.26510, 0.26240, 0.25980, 0.25460, 0.24970, 0.245, 0.24050, 0.23610, 0.23190, 0.22780, 0.22390, + 0.22010, 0.21640, 0.21290, 0.20940, 0.20610, 0.20290, 3.542e-05, 0.18040, 0.1687}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.39460, 0.39230, 0.39010, 0.38780, 0.38560, 0.38340, + 0.38230, 0.38120, 0.38020, 0.37910, 0.37810, 0.377, 0.376, 0.37490, 0.37390, 0.37290, 0.37190, 0.37080, 0.36980, 0.36880, 0.36780, + 0.36690, 0.36590, 0.36490, 0.36390, 0.363, 0.362, 0.361, 0.36010, 0.35920, 0.35820, 0.35730, 0.35640, 0.35540, 0.35450, 0.35360, + 0.35270, 0.35180, 0.35, 0.34820, 0.34650, 0.34470, 0.343, 0.34130, 0.33970, 0.338, 0.33640, 0.33470, 0.33310, 0.33150, 0.32990, + 0.32840, 0.32680, 0.32530, 0.32380, 0.32230, 0.32080, 0.31930, 0.31780, 0.31640, 0.315, 0.31350, 0.31210, 0.30870, 0.30530, 0.302, + 0.29870, 0.29560, 0.29250, 0.28940, 0.28650, 0.28360, 0.28070, 0.27520, 0.26990, 0.26480, 0.25990, 0.25510, 0.25060, 0.24620, 0.24190, + 0.23780, 0.23390, 0.23, 0.22630, 0.22270, 0.21930, 3.542e-05, 0.19490, 0.1823}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42390, 0.42140, 0.419, 0.41660, 0.41420, + 0.413, 0.41190, 0.41070, 0.40960, 0.40840, 0.40730, 0.40610, 0.405, 0.40390, 0.40280, 0.40170, 0.40060, 0.39950, 0.39840, 0.39730, + 0.39630, 0.39520, 0.39410, 0.39310, 0.392, 0.391, 0.39, 0.38890, 0.38790, 0.38690, 0.38590, 0.38490, 0.38390, 0.38290, 0.38190, + 0.38090, 0.37990, 0.378, 0.37610, 0.37420, 0.37230, 0.37050, 0.36860, 0.36680, 0.365, 0.36320, 0.36150, 0.35970, 0.358, 0.35630, + 0.35460, 0.35290, 0.35130, 0.34960, 0.348, 0.34640, 0.34480, 0.34320, 0.34160, 0.34010, 0.33860, 0.337, 0.33330, 0.32960, 0.32610, + 0.32260, 0.31910, 0.31580, 0.31250, 0.30930, 0.30620, 0.30310, 0.29710, 0.29140, 0.28590, 0.28060, 0.27540, 0.27050, 0.26580, 0.26120, + 0.25680, 0.25250, 0.24830, 0.24430, 0.24050, 0.23670, 3.542e-05, 0.21040, 0.1968}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.45490, 0.45230, 0.44970, 0.44710, + 0.44580, 0.44450, 0.44330, 0.442, 0.44080, 0.43960, 0.43830, 0.43710, 0.43590, 0.43470, 0.43350, 0.43230, 0.43110, 0.43, 0.42880, + 0.42760, 0.42650, 0.42530, 0.42420, 0.42310, 0.42190, 0.42080, 0.41970, 0.41860, 0.41750, 0.41640, 0.41530, 0.41420, 0.41320, 0.41210, + 0.411, 0.41, 0.40790, 0.40580, 0.40380, 0.40170, 0.39970, 0.39770, 0.39580, 0.39380, 0.39190, 0.39, 0.38810, 0.38620, 0.38440, + 0.38260, 0.38080, 0.379, 0.37720, 0.37540, 0.37370, 0.372, 0.37030, 0.36860, 0.36690, 0.36520, 0.36360, 0.35950, 0.35560, 0.35170, + 0.34790, 0.34420, 0.34060, 0.33710, 0.33360, 0.33020, 0.32690, 0.32050, 0.31430, 0.30830, 0.30260, 0.29710, 0.29180, 0.28660, 0.28170, + 0.27690, 0.27230, 0.26780, 0.26350, 0.25930, 0.25530, 3.542e-05, 0.22690, 0.2122}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.48780, 0.48490, 0.48210, + 0.48080, 0.47940, 0.478, 0.47670, 0.47530, 0.474, 0.47270, 0.47130, 0.47, 0.46870, 0.46740, 0.46620, 0.46490, 0.46360, 0.46230, + 0.46110, 0.45980, 0.45860, 0.45740, 0.45610, 0.45490, 0.45370, 0.45250, 0.45130, 0.45010, 0.44890, 0.44780, 0.44660, 0.44540, 0.44430, + 0.44310, 0.442, 0.43970, 0.43750, 0.43530, 0.43310, 0.43090, 0.42870, 0.42660, 0.42450, 0.42240, 0.42040, 0.41830, 0.41630, 0.41430, + 0.41240, 0.41040, 0.40850, 0.40650, 0.40460, 0.40280, 0.40090, 0.39910, 0.39720, 0.39540, 0.39360, 0.39190, 0.38750, 0.38320, 0.37910, + 0.375, 0.371, 0.36710, 0.36330, 0.35950, 0.35590, 0.35230, 0.34530, 0.33870, 0.33230, 0.32610, 0.32010, 0.31440, 0.30890, 0.30350, + 0.29840, 0.29340, 0.28860, 0.28390, 0.27940, 0.27510, 3.542e-05, 0.24450, 0.2287}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.52250, 0.51950, + 0.518, 0.51650, 0.51510, 0.51360, 0.51210, 0.51070, 0.50920, 0.50780, 0.50640, 0.505, 0.50360, 0.50220, 0.50080, 0.49940, 0.49810, + 0.49670, 0.49540, 0.494, 0.49270, 0.49140, 0.49010, 0.48870, 0.48740, 0.48610, 0.48490, 0.48360, 0.48230, 0.481, 0.47980, 0.47850, + 0.47730, 0.47610, 0.47360, 0.47120, 0.46880, 0.46640, 0.46410, 0.46180, 0.45950, 0.45720, 0.455, 0.45270, 0.45050, 0.44840, 0.44620, + 0.44410, 0.442, 0.43990, 0.43780, 0.43580, 0.43370, 0.43170, 0.42970, 0.42780, 0.42580, 0.42390, 0.422, 0.41730, 0.41270, 0.40820, + 0.40380, 0.39950, 0.39530, 0.39110, 0.38710, 0.38320, 0.37930, 0.37180, 0.36460, 0.35770, 0.35110, 0.34460, 0.33850, 0.33250, 0.32680, + 0.32120, 0.31590, 0.31070, 0.30570, 0.30080, 0.29610, 3.542e-05, 0.26320, 0.2461}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.55930, + 0.55770, 0.55610, 0.55450, 0.55290, 0.55130, 0.54980, 0.54820, 0.54670, 0.54510, 0.54360, 0.54210, 0.54060, 0.53910, 0.53760, 0.53610, + 0.53460, 0.53320, 0.53170, 0.53030, 0.52890, 0.52740, 0.526, 0.52460, 0.52320, 0.52180, 0.52050, 0.51910, 0.51770, 0.51640, 0.515, + 0.51370, 0.51230, 0.50970, 0.50710, 0.50450, 0.50190, 0.49940, 0.49690, 0.49440, 0.492, 0.48960, 0.48720, 0.48480, 0.48240, 0.48010, + 0.47780, 0.47550, 0.47330, 0.47110, 0.46880, 0.46670, 0.46450, 0.46230, 0.46020, 0.45810, 0.456, 0.454, 0.44890, 0.44390, 0.43910, + 0.43440, 0.42970, 0.42520, 0.42080, 0.41640, 0.41220, 0.408, 0.4, 0.39220, 0.38480, 0.37760, 0.37070, 0.36410, 0.35760, 0.35150, + 0.34550, 0.33970, 0.33410, 0.32870, 0.32350, 0.31850, 3.542e-05, 0.28310, 0.2647}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.57850, 0.57680, 0.57510, 0.57350, 0.57180, 0.57020, 0.56860, 0.567, 0.56540, 0.56380, 0.56220, 0.56070, 0.55910, 0.55760, 0.556, + 0.55450, 0.553, 0.55150, 0.55, 0.54850, 0.547, 0.54550, 0.54410, 0.54260, 0.54120, 0.53980, 0.53830, 0.53690, 0.53550, 0.53410, + 0.53270, 0.53130, 0.52860, 0.52590, 0.52320, 0.52050, 0.51790, 0.51530, 0.51270, 0.51020, 0.50770, 0.50520, 0.50270, 0.50030, 0.49790, + 0.49550, 0.49310, 0.49080, 0.48850, 0.48620, 0.48390, 0.48160, 0.47940, 0.47720, 0.475, 0.47290, 0.47070, 0.46550, 0.46030, 0.45530, + 0.45040, 0.44560, 0.44090, 0.43630, 0.43180, 0.42740, 0.423, 0.41470, 0.40660, 0.39890, 0.39150, 0.38430, 0.37740, 0.37080, 0.36440, + 0.35820, 0.35220, 0.34640, 0.34080, 0.33540, 0.33020, 3.542e-05, 0.29350, 0.2744}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.59820, 0.59640, 0.59470, 0.593, 0.59130, 0.58960, 0.588, 0.58630, 0.58470, 0.583, 0.58140, 0.57980, 0.57820, 0.57660, + 0.575, 0.57340, 0.57180, 0.57030, 0.56870, 0.56720, 0.56570, 0.56420, 0.56270, 0.56120, 0.55970, 0.55820, 0.55670, 0.55520, 0.55380, + 0.55230, 0.55090, 0.548, 0.54520, 0.54240, 0.53970, 0.53690, 0.53420, 0.53160, 0.52890, 0.52630, 0.52370, 0.52120, 0.51870, 0.51620, + 0.51370, 0.51120, 0.50880, 0.50640, 0.504, 0.50170, 0.49930, 0.497, 0.49470, 0.49250, 0.49020, 0.488, 0.48250, 0.47720, 0.472, + 0.46690, 0.46190, 0.457, 0.45220, 0.44760, 0.443, 0.43850, 0.42980, 0.42150, 0.41350, 0.40580, 0.39840, 0.39120, 0.38430, 0.37770, + 0.37130, 0.36510, 0.35910, 0.35330, 0.34760, 0.34220, 3.542e-05, 0.30420, 0.2844}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.61840, 0.61660, 0.61480, 0.61310, 0.61130, 0.60960, 0.60790, 0.60620, 0.60450, 0.60280, 0.60110, 0.59940, 0.59780, + 0.59610, 0.59450, 0.59280, 0.59120, 0.58960, 0.588, 0.58640, 0.58490, 0.58330, 0.58170, 0.58020, 0.57860, 0.57710, 0.57560, 0.57410, + 0.57260, 0.57110, 0.56810, 0.56520, 0.56230, 0.55940, 0.55660, 0.55380, 0.551, 0.54830, 0.54560, 0.54290, 0.54020, 0.53760, 0.535, + 0.53240, 0.52990, 0.52740, 0.52490, 0.52240, 0.52, 0.51750, 0.51510, 0.51280, 0.51040, 0.50810, 0.50580, 0.50010, 0.49460, 0.48920, + 0.48390, 0.47870, 0.47360, 0.46870, 0.46390, 0.45910, 0.45450, 0.44550, 0.43680, 0.42850, 0.42050, 0.41290, 0.40540, 0.39830, 0.39140, + 0.38470, 0.37830, 0.37210, 0.36610, 0.36030, 0.35460, 3.542e-05, 0.31520, 0.2948}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.63920, 0.63740, 0.63550, 0.63370, 0.63190, 0.63010, 0.62830, 0.62660, 0.62480, 0.623, 0.62130, 0.61960, + 0.61790, 0.61620, 0.61450, 0.61280, 0.61110, 0.60950, 0.60780, 0.60620, 0.60460, 0.60290, 0.60130, 0.59970, 0.59810, 0.59660, 0.595, + 0.59340, 0.59190, 0.58880, 0.58580, 0.58270, 0.57980, 0.57680, 0.57390, 0.571, 0.56820, 0.56540, 0.56260, 0.55990, 0.55710, 0.55440, + 0.55180, 0.54910, 0.54650, 0.54390, 0.54140, 0.53880, 0.53630, 0.53380, 0.53140, 0.52890, 0.52650, 0.52410, 0.51820, 0.51250, 0.50690, + 0.50140, 0.496, 0.49080, 0.48570, 0.48060, 0.47570, 0.47090, 0.46160, 0.45260, 0.444, 0.43570, 0.42780, 0.42010, 0.41270, 0.40550, + 0.39860, 0.392, 0.38550, 0.37930, 0.37330, 0.36740, 3.542e-05, 0.32660, 0.3054}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.66060, 0.65870, 0.65680, 0.65490, 0.653, 0.65120, 0.64930, 0.64750, 0.64570, 0.64390, 0.64210, + 0.64030, 0.63850, 0.63680, 0.635, 0.63330, 0.63160, 0.62990, 0.62820, 0.62650, 0.62480, 0.62310, 0.62150, 0.61980, 0.61820, 0.61650, + 0.61490, 0.61330, 0.61010, 0.607, 0.60380, 0.60070, 0.59770, 0.59470, 0.59170, 0.58870, 0.58580, 0.58290, 0.58010, 0.57720, 0.57440, + 0.57170, 0.56890, 0.56620, 0.56350, 0.56090, 0.55820, 0.55560, 0.55310, 0.55050, 0.548, 0.54550, 0.543, 0.53690, 0.53090, 0.52510, + 0.51940, 0.51390, 0.50840, 0.50310, 0.49790, 0.49280, 0.48780, 0.47820, 0.46890, 0.46, 0.45140, 0.44310, 0.43510, 0.42750, 0.42010, + 0.41290, 0.406, 0.39930, 0.39290, 0.38660, 0.38060, 3.542e-05, 0.33830, 0.3163}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.68250, 0.68050, 0.67860, 0.67660, 0.67470, 0.67280, 0.67090, 0.669, 0.66710, 0.66530, + 0.66340, 0.66160, 0.65980, 0.658, 0.65620, 0.65440, 0.65260, 0.65080, 0.64910, 0.64730, 0.64560, 0.64390, 0.64210, 0.64040, 0.63870, + 0.63710, 0.63540, 0.63210, 0.62880, 0.62550, 0.62230, 0.61920, 0.616, 0.61290, 0.60990, 0.60690, 0.60390, 0.60090, 0.598, 0.59510, + 0.59220, 0.58930, 0.58650, 0.58370, 0.581, 0.57830, 0.57560, 0.57290, 0.57020, 0.56760, 0.565, 0.56240, 0.55610, 0.54990, 0.54390, + 0.538, 0.53230, 0.52660, 0.52110, 0.51570, 0.51040, 0.50530, 0.49520, 0.48560, 0.47640, 0.46750, 0.45890, 0.45070, 0.44270, 0.435, + 0.42760, 0.42050, 0.41360, 0.40690, 0.40040, 0.39410, 3.542e-05, 0.35030, 0.3276}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.705, 0.703, 0.701, 0.699, 0.697, 0.695, 0.69310, 0.69110, 0.68920, + 0.68730, 0.68530, 0.68350, 0.68160, 0.67970, 0.67780, 0.676, 0.67420, 0.67230, 0.67050, 0.66870, 0.66690, 0.66510, 0.66340, 0.66160, + 0.65990, 0.65810, 0.65470, 0.65130, 0.64790, 0.64460, 0.64130, 0.63810, 0.63480, 0.63170, 0.62850, 0.62540, 0.62230, 0.61930, 0.61630, + 0.61330, 0.61040, 0.60740, 0.60460, 0.60170, 0.59890, 0.59610, 0.59330, 0.59050, 0.58780, 0.58510, 0.58250, 0.57590, 0.56950, 0.56330, + 0.55710, 0.55120, 0.54530, 0.53960, 0.534, 0.52860, 0.52320, 0.51280, 0.50280, 0.49330, 0.484, 0.47520, 0.46660, 0.45840, 0.45050, + 0.44280, 0.43540, 0.42820, 0.42130, 0.41460, 0.40810, 3.542e-05, 0.36270, 0.3391}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.72820, 0.72610, 0.724, 0.72190, 0.71990, 0.71780, 0.71580, 0.71380, + 0.71180, 0.70980, 0.70790, 0.70590, 0.704, 0.702, 0.70010, 0.69820, 0.69630, 0.69440, 0.69250, 0.69070, 0.68880, 0.687, 0.68520, + 0.68340, 0.68160, 0.678, 0.67450, 0.671, 0.66750, 0.66410, 0.66070, 0.65740, 0.65410, 0.65080, 0.64760, 0.64440, 0.64130, 0.63810, + 0.63510, 0.632, 0.629, 0.626, 0.623, 0.62010, 0.61720, 0.61430, 0.61150, 0.60860, 0.60580, 0.60310, 0.59630, 0.58960, 0.58320, + 0.57680, 0.57060, 0.56460, 0.55870, 0.55290, 0.54720, 0.54170, 0.53090, 0.52060, 0.51060, 0.50110, 0.49190, 0.48310, 0.47450, 0.46630, + 0.45840, 0.45070, 0.44330, 0.43610, 0.42920, 0.42240, 3.542e-05, 0.37540, 0.3511}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75190, 0.74970, 0.74760, 0.74550, 0.74330, 0.74120, 0.73920, + 0.73710, 0.735, 0.733, 0.73090, 0.72890, 0.72690, 0.72490, 0.723, 0.721, 0.719, 0.71710, 0.71520, 0.71320, 0.71130, 0.70940, + 0.70760, 0.70570, 0.702, 0.69830, 0.69470, 0.69110, 0.68760, 0.68410, 0.68060, 0.67720, 0.67380, 0.67050, 0.66720, 0.66390, 0.66060, + 0.65740, 0.65430, 0.65110, 0.648, 0.645, 0.64190, 0.63890, 0.63590, 0.633, 0.63010, 0.62720, 0.62430, 0.61730, 0.61040, 0.60370, + 0.59710, 0.59070, 0.58440, 0.57830, 0.57230, 0.56640, 0.56070, 0.54950, 0.53880, 0.52850, 0.51870, 0.50910, 0.5, 0.49120, 0.48260, + 0.47440, 0.46650, 0.45880, 0.45140, 0.44420, 0.43720, 3.542e-05, 0.38860, 0.3633}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.77630, 0.774, 0.77180, 0.76960, 0.76740, 0.76530, + 0.76310, 0.761, 0.75890, 0.75670, 0.75470, 0.75260, 0.75050, 0.74840, 0.74640, 0.74440, 0.74240, 0.74040, 0.73840, 0.73640, 0.73440, + 0.73250, 0.73050, 0.72670, 0.72290, 0.71910, 0.71540, 0.71170, 0.70810, 0.70450, 0.701, 0.69750, 0.694, 0.69060, 0.68720, 0.68380, + 0.68050, 0.67720, 0.674, 0.67070, 0.66760, 0.66440, 0.66130, 0.65820, 0.65510, 0.65210, 0.64910, 0.64610, 0.63880, 0.63170, 0.62480, + 0.618, 0.61130, 0.60480, 0.59850, 0.59230, 0.58620, 0.58020, 0.56870, 0.55760, 0.547, 0.53670, 0.52690, 0.51740, 0.50820, 0.49940, + 0.49090, 0.48270, 0.47470, 0.46710, 0.45960, 0.45240, 3.542e-05, 0.40210, 0.3759}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.80130, 0.799, 0.79670, 0.79440, 0.79220, + 0.78990, 0.78770, 0.78550, 0.78330, 0.78110, 0.779, 0.77680, 0.77470, 0.77260, 0.77050, 0.76840, 0.76630, 0.76420, 0.76220, 0.76010, + 0.75810, 0.75610, 0.75210, 0.74820, 0.74430, 0.74040, 0.73660, 0.73280, 0.72910, 0.72540, 0.72180, 0.71820, 0.71470, 0.71110, 0.70770, + 0.70420, 0.70080, 0.69740, 0.69410, 0.69080, 0.68750, 0.68430, 0.68110, 0.67790, 0.67480, 0.67170, 0.66860, 0.661, 0.65370, 0.64650, + 0.63940, 0.63250, 0.62580, 0.61920, 0.61280, 0.60650, 0.60030, 0.58840, 0.57690, 0.56590, 0.55530, 0.54510, 0.53530, 0.52580, 0.51670, + 0.50790, 0.49940, 0.49110, 0.48320, 0.47550, 0.468, 3.542e-05, 0.41590, 0.3889}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.82690, 0.82460, 0.82220, 0.81990, + 0.81750, 0.81520, 0.81290, 0.81070, 0.80840, 0.80620, 0.80390, 0.80170, 0.79950, 0.79730, 0.79520, 0.793, 0.79090, 0.78870, 0.78660, + 0.78450, 0.78240, 0.77830, 0.77420, 0.77010, 0.76610, 0.76220, 0.75830, 0.75440, 0.75060, 0.74690, 0.74310, 0.73940, 0.73580, 0.73220, + 0.72860, 0.72510, 0.72160, 0.71810, 0.71470, 0.71130, 0.708, 0.70470, 0.70140, 0.69810, 0.69490, 0.69170, 0.68390, 0.67630, 0.66880, + 0.66150, 0.65440, 0.64740, 0.64060, 0.63390, 0.62740, 0.621, 0.60870, 0.59680, 0.58540, 0.57440, 0.56390, 0.55370, 0.54390, 0.53450, + 0.52530, 0.51650, 0.508, 0.49980, 0.49180, 0.48410, 3.542e-05, 0.43020, 0.4023}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.85320, 0.85080, 0.84840, + 0.846, 0.84360, 0.84120, 0.83880, 0.83650, 0.83410, 0.83180, 0.82950, 0.82730, 0.825, 0.82270, 0.82050, 0.81830, 0.81610, 0.81390, + 0.81170, 0.80950, 0.80520, 0.801, 0.79680, 0.79260, 0.78850, 0.78450, 0.78050, 0.77650, 0.77260, 0.76880, 0.76490, 0.76120, 0.75740, + 0.75370, 0.75010, 0.74650, 0.74290, 0.73930, 0.73580, 0.73240, 0.72890, 0.72550, 0.72210, 0.71880, 0.71550, 0.70740, 0.69950, 0.69180, + 0.68420, 0.67680, 0.66960, 0.66260, 0.65570, 0.64890, 0.64230, 0.62950, 0.61720, 0.60540, 0.59410, 0.58310, 0.57260, 0.56250, 0.55270, + 0.54330, 0.53420, 0.52540, 0.51690, 0.50860, 0.50060, 3.542e-05, 0.44490, 0.416}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.88020, 0.87770, + 0.87520, 0.87270, 0.87030, 0.86780, 0.86540, 0.86290, 0.86050, 0.85820, 0.85580, 0.85340, 0.85110, 0.84880, 0.84650, 0.84420, 0.84190, + 0.83960, 0.83740, 0.83290, 0.82850, 0.82420, 0.81990, 0.81560, 0.81140, 0.80730, 0.80320, 0.79920, 0.79510, 0.79120, 0.78730, 0.78340, + 0.77960, 0.77580, 0.772, 0.76830, 0.76460, 0.761, 0.75740, 0.75390, 0.75030, 0.74680, 0.74340, 0.74, 0.73160, 0.72340, 0.71540, + 0.70760, 0.69990, 0.69240, 0.68510, 0.678, 0.671, 0.66420, 0.65090, 0.63820, 0.626, 0.61430, 0.603, 0.59210, 0.58160, 0.57150, + 0.56170, 0.55230, 0.54320, 0.53440, 0.52590, 0.51760, 3.542e-05, 0.46, 0.4301}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.90790, + 0.90530, 0.90270, 0.90020, 0.89760, 0.89510, 0.89260, 0.89010, 0.88760, 0.88520, 0.88270, 0.88030, 0.87790, 0.87550, 0.87310, 0.87070, + 0.86840, 0.86610, 0.86140, 0.85690, 0.85240, 0.84790, 0.84350, 0.83920, 0.83490, 0.83060, 0.82640, 0.82230, 0.81820, 0.81410, 0.81010, + 0.80610, 0.80220, 0.79830, 0.79450, 0.79070, 0.78690, 0.78320, 0.77950, 0.77590, 0.77220, 0.76870, 0.76510, 0.75640, 0.74790, 0.73970, + 0.73160, 0.72370, 0.71590, 0.70840, 0.701, 0.69380, 0.68670, 0.673, 0.65980, 0.64720, 0.635, 0.62340, 0.61210, 0.60130, 0.59080, + 0.58070, 0.571, 0.56150, 0.55240, 0.54360, 0.53510, 3.542e-05, 0.47550, 0.4446}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.93630, 0.93360, 0.931, 0.92830, 0.92570, 0.92310, 0.92050, 0.91790, 0.91540, 0.91280, 0.91030, 0.90780, 0.90530, 0.90290, 0.90040, + 0.898, 0.89560, 0.89080, 0.886, 0.88140, 0.87680, 0.87220, 0.86770, 0.86320, 0.85880, 0.85450, 0.85020, 0.84590, 0.84170, 0.83760, + 0.83340, 0.82940, 0.82540, 0.82140, 0.81740, 0.81350, 0.80970, 0.80590, 0.80210, 0.79840, 0.79460, 0.791, 0.782, 0.77320, 0.76460, + 0.75620, 0.74810, 0.74010, 0.73220, 0.72460, 0.71710, 0.70980, 0.69560, 0.682, 0.66890, 0.65640, 0.64430, 0.63270, 0.62150, 0.61060, + 0.60020, 0.59010, 0.58040, 0.571, 0.56190, 0.553, 3.542e-05, 0.49140, 0.4594}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.96540, 0.96260, 0.95990, 0.95720, 0.95450, 0.95180, 0.94910, 0.94650, 0.94380, 0.94120, 0.93860, 0.93610, 0.93350, 0.93090, + 0.92840, 0.92590, 0.92090, 0.916, 0.91120, 0.90640, 0.90170, 0.897, 0.89240, 0.88780, 0.88330, 0.87890, 0.87450, 0.87010, 0.86580, + 0.86150, 0.85730, 0.85320, 0.849, 0.845, 0.84090, 0.83690, 0.833, 0.82910, 0.82520, 0.82140, 0.81760, 0.80830, 0.79920, 0.79030, + 0.78160, 0.77310, 0.76490, 0.75680, 0.74890, 0.74110, 0.73360, 0.71890, 0.70480, 0.69130, 0.67830, 0.66580, 0.65380, 0.64220, 0.631, + 0.62020, 0.60980, 0.59970, 0.59, 0.58060, 0.57150, 3.542e-05, 0.50780, 0.4747}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.99520, 0.99240, 0.98950, 0.98670, 0.984, 0.98120, 0.97840, 0.97570, 0.973, 0.97030, 0.96760, 0.965, 0.96230, + 0.95970, 0.95710, 0.952, 0.94690, 0.94190, 0.93690, 0.932, 0.92720, 0.92240, 0.91770, 0.913, 0.90840, 0.90380, 0.89930, 0.89480, + 0.89040, 0.88610, 0.88170, 0.87750, 0.87320, 0.86910, 0.86490, 0.86080, 0.85680, 0.85280, 0.84880, 0.84490, 0.83520, 0.82580, 0.81670, + 0.80770, 0.79890, 0.79040, 0.782, 0.77380, 0.76580, 0.758, 0.74280, 0.72830, 0.71430, 0.70090, 0.68790, 0.67550, 0.66350, 0.652, + 0.64080, 0.63, 0.61960, 0.60960, 0.59980, 0.59040, 3.542e-05, 0.52460, 0.4905}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 1.026, 1.023, 1.02, 1.017, 1.014, 1.011, 1.008, 1.006, 1.003, 1.0, 0.99740, 0.99460, + 0.99190, 0.98920, 0.98390, 0.97860, 0.97340, 0.96830, 0.96320, 0.95820, 0.95320, 0.94830, 0.94350, 0.93870, 0.934, 0.92930, 0.92470, + 0.92010, 0.91560, 0.91110, 0.90670, 0.90230, 0.898, 0.89370, 0.88950, 0.88530, 0.88110, 0.877, 0.873, 0.863, 0.85330, 0.84380, + 0.83450, 0.82540, 0.81660, 0.80790, 0.79940, 0.79120, 0.78310, 0.76740, 0.75230, 0.73790, 0.724, 0.71060, 0.69780, 0.68540, 0.67350, + 0.66190, 0.65080, 0.64010, 0.62970, 0.61960, 0.60990, 3.542e-05, 0.54180, 0.5066}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 1.057, 1.054, 1.051, 1.048, 1.045, 1.042, 1.039, 1.036, 1.034, 1.031, 1.028, + 1.025, 1.022, 1.017, 1.011, 1.006, 1.0, 0.99520, 0.99, 0.98490, 0.97980, 0.97480, 0.96990, 0.965, 0.96010, 0.95530, + 0.95060, 0.94590, 0.94130, 0.93670, 0.93220, 0.92770, 0.92330, 0.91890, 0.91460, 0.91030, 0.906, 0.90180, 0.89150, 0.88140, 0.87160, + 0.862, 0.85260, 0.84350, 0.83450, 0.82580, 0.81720, 0.80880, 0.79260, 0.77710, 0.76210, 0.74780, 0.734, 0.72070, 0.70790, 0.69550, + 0.68360, 0.67210, 0.661, 0.65030, 0.63990, 0.62980, 3.542e-05, 0.55960, 0.5232}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 1.089, 1.086, 1.083, 1.08, 1.077, 1.074, 1.071, 1.068, 1.065, 1.062, + 1.059, 1.056, 1.05, 1.045, 1.039, 1.034, 1.028, 1.023, 1.017, 1.012, 1.007, 1.002, 0.99680, 0.99180, 0.98680, + 0.982, 0.97710, 0.97230, 0.96760, 0.96290, 0.95830, 0.95370, 0.94910, 0.94470, 0.94020, 0.93580, 0.93150, 0.92080, 0.91040, 0.90020, + 0.89030, 0.88060, 0.87110, 0.86190, 0.85280, 0.844, 0.83530, 0.81850, 0.80250, 0.787, 0.77220, 0.75790, 0.74420, 0.731, 0.71820, + 0.70590, 0.694, 0.68260, 0.67150, 0.66070, 0.65030, 3.542e-05, 0.57780, 0.5402}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.122, 1.119, 1.116, 1.113, 1.109, 1.106, 1.103, 1.1, 1.097, + 1.094, 1.091, 1.085, 1.079, 1.073, 1.068, 1.062, 1.056, 1.051, 1.045, 1.04, 1.035, 1.03, 1.024, 1.019, + 1.014, 1.009, 1.004, 0.99930, 0.99440, 0.98960, 0.98490, 0.98020, 0.97560, 0.971, 0.96640, 0.96190, 0.95090, 0.94010, 0.92960, + 0.91930, 0.90930, 0.89950, 0.88990, 0.88060, 0.87140, 0.86250, 0.84510, 0.82850, 0.81260, 0.79730, 0.78250, 0.76830, 0.75470, 0.74150, + 0.72880, 0.71650, 0.70470, 0.69320, 0.68210, 0.67140, 3.542e-05, 0.59640, 0.5576}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.156, 1.152, 1.149, 1.146, 1.143, 1.139, 1.136, 1.133, + 1.13, 1.127, 1.121, 1.115, 1.109, 1.103, 1.097, 1.091, 1.085, 1.08, 1.074, 1.069, 1.063, 1.058, 1.052, + 1.047, 1.042, 1.037, 1.032, 1.027, 1.022, 1.017, 1.012, 1.007, 1.003, 0.99790, 0.99320, 0.98180, 0.97060, 0.95970, + 0.94910, 0.93880, 0.92860, 0.91880, 0.90910, 0.89960, 0.89040, 0.87250, 0.85530, 0.83880, 0.823, 0.80780, 0.79310, 0.779, 0.76540, + 0.75230, 0.73960, 0.72740, 0.71550, 0.70410, 0.693, 3.542e-05, 0.61560, 0.5755}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.19, 1.187, 1.183, 1.18, 1.177, 1.173, 1.17, + 1.167, 1.164, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.121, 1.115, 1.109, 1.103, 1.098, 1.092, 1.087, + 1.081, 1.076, 1.071, 1.065, 1.06, 1.055, 1.05, 1.045, 1.04, 1.035, 1.03, 1.025, 1.013, 1.002, 0.99070, + 0.97970, 0.969, 0.95860, 0.94840, 0.93840, 0.92860, 0.919, 0.90050, 0.88280, 0.86580, 0.84940, 0.83370, 0.81860, 0.804, 0.78990, + 0.77640, 0.76330, 0.75070, 0.73840, 0.72660, 0.71520, 3.542e-05, 0.63530, 0.5939}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.226, 1.222, 1.219, 1.215, 1.212, 1.208, + 1.205, 1.202, 1.195, 1.188, 1.182, 1.176, 1.169, 1.163, 1.157, 1.151, 1.145, 1.139, 1.133, 1.127, 1.122, + 1.116, 1.111, 1.105, 1.1, 1.094, 1.089, 1.084, 1.079, 1.073, 1.068, 1.063, 1.058, 1.046, 1.034, 1.023, + 1.011, 1.0, 0.98930, 0.97870, 0.96840, 0.95830, 0.94840, 0.92930, 0.911, 0.89340, 0.87650, 0.86030, 0.84470, 0.82960, 0.81510, + 0.80110, 0.78760, 0.77460, 0.76190, 0.74970, 0.73790, 3.542e-05, 0.65550, 0.6128}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.262, 1.258, 1.254, 1.251, 1.247, + 1.244, 1.24, 1.234, 1.227, 1.22, 1.213, 1.207, 1.201, 1.194, 1.188, 1.182, 1.176, 1.17, 1.164, 1.158, + 1.152, 1.146, 1.141, 1.135, 1.129, 1.124, 1.118, 1.113, 1.108, 1.102, 1.097, 1.092, 1.08, 1.067, 1.055, + 1.043, 1.032, 1.021, 1.01, 0.99920, 0.98880, 0.97860, 0.95890, 0.93990, 0.92180, 0.90440, 0.88760, 0.87150, 0.85590, 0.84090, + 0.82650, 0.81260, 0.79910, 0.78610, 0.77350, 0.76130, 3.542e-05, 0.67620, 0.6321}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.299, 1.295, 1.291, 1.288, + 1.284, 1.28, 1.273, 1.266, 1.259, 1.252, 1.246, 1.239, 1.232, 1.226, 1.22, 1.213, 1.207, 1.201, 1.195, + 1.189, 1.183, 1.177, 1.171, 1.165, 1.16, 1.154, 1.149, 1.143, 1.138, 1.132, 1.127, 1.114, 1.101, 1.089, + 1.077, 1.065, 1.053, 1.042, 1.031, 1.02, 1.01, 0.98920, 0.96960, 0.95090, 0.93290, 0.91560, 0.89890, 0.88290, 0.86740, + 0.85250, 0.83810, 0.82420, 0.81080, 0.79780, 0.78520, 3.542e-05, 0.69740, 0.652}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.337, 1.333, 1.329, + 1.325, 1.321, 1.314, 1.307, 1.3, 1.292, 1.285, 1.279, 1.272, 1.265, 1.258, 1.252, 1.245, 1.239, 1.233, + 1.227, 1.22, 1.214, 1.208, 1.202, 1.196, 1.191, 1.185, 1.179, 1.174, 1.168, 1.163, 1.149, 1.136, 1.123, + 1.111, 1.098, 1.086, 1.075, 1.063, 1.052, 1.041, 1.02, 1.0, 0.98080, 0.96220, 0.94430, 0.92710, 0.91060, 0.89460, + 0.87920, 0.86440, 0.85, 0.83620, 0.82280, 0.80980, 3.542e-05, 0.7192, 0.6723}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.375, 1.371, + 1.367, 1.364, 1.356, 1.348, 1.341, 1.334, 1.326, 1.319, 1.312, 1.305, 1.298, 1.292, 1.285, 1.278, 1.272, + 1.265, 1.259, 1.253, 1.246, 1.24, 1.234, 1.228, 1.222, 1.216, 1.211, 1.205, 1.199, 1.185, 1.172, 1.158, + 1.145, 1.133, 1.12, 1.108, 1.097, 1.085, 1.074, 1.052, 1.031, 1.011, 0.99220, 0.97380, 0.956, 0.939, 0.92250, + 0.90660, 0.89130, 0.87650, 0.86220, 0.84840, 0.835, 3.542e-05, 0.7416, 0.6932}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.415, + 1.411, 1.407, 1.399, 1.391, 1.383, 1.376, 1.368, 1.361, 1.354, 1.346, 1.339, 1.332, 1.325, 1.319, 1.312, + 1.305, 1.299, 1.292, 1.286, 1.279, 1.273, 1.267, 1.261, 1.255, 1.249, 1.243, 1.237, 1.222, 1.208, 1.195, + 1.181, 1.168, 1.155, 1.143, 1.131, 1.119, 1.107, 1.085, 1.063, 1.043, 1.023, 1.004, 0.98570, 0.96810, 0.95110, + 0.93470, 0.91890, 0.90360, 0.88890, 0.87460, 0.86080, 3.542e-05, 0.7645, 0.7146}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 1.455, 1.451, 1.443, 1.435, 1.427, 1.419, 1.411, 1.404, 1.396, 1.389, 1.381, 1.374, 1.367, 1.36, 1.353, + 1.346, 1.339, 1.332, 1.326, 1.319, 1.313, 1.306, 1.3, 1.294, 1.287, 1.281, 1.275, 1.26, 1.246, 1.232, + 1.218, 1.204, 1.191, 1.178, 1.166, 1.154, 1.142, 1.118, 1.096, 1.075, 1.055, 1.035, 1.016, 0.99790, 0.98040, + 0.96350, 0.94720, 0.93140, 0.91620, 0.90150, 0.88730, 3.542e-05, 0.7879, 0.7365}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.497, 1.488, 1.48, 1.472, 1.464, 1.456, 1.448, + 1.44, 1.432, 1.425, 1.417, 1.41, 1.402, 1.395, 1.388, 1.381, 1.374, 1.367, 1.36, 1.354, 1.347, 1.34, 1.334, 1.327, + 1.321, 1.315, 1.299, 1.284, 1.27, 1.255, 1.242, 1.228, 1.215, 1.202, 1.189, 1.177, 1.153, 1.13, 1.108, 1.087, 1.067, + 1.047, 1.028, 1.01, 0.993, 0.97620, 0.95990, 0.94420, 0.92910, 0.91440, 3.542e-05, 0.812, 0.759}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.583, 1.574, 1.565, 1.556, 1.548, 1.539, + 1.531, 1.522, 1.514, 1.506, 1.498, 1.49, 1.483, 1.475, 1.468, 1.46, 1.453, 1.445, 1.438, 1.431, 1.424, 1.417, 1.41, + 1.404, 1.397, 1.38, 1.364, 1.349, 1.334, 1.319, 1.304, 1.29, 1.276, 1.263, 1.25, 1.224, 1.2, 1.177, 1.154, 1.133, + 1.112, 1.092, 1.073, 1.054, 1.036, 1.019, 1.002, 0.98630, 0.97070, 3.542e-05, 0.8619, 0.8056}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.673, 1.663, 1.654, 1.644, 1.635, + 1.626, 1.617, 1.609, 1.6, 1.592, 1.583, 1.575, 1.567, 1.559, 1.551, 1.543, 1.535, 1.527, 1.52, 1.512, 1.505, 1.498, + 1.49, 1.483, 1.466, 1.449, 1.432, 1.416, 1.4, 1.385, 1.37, 1.355, 1.341, 1.327, 1.299, 1.273, 1.249, 1.225, 1.202, + 1.18, 1.159, 1.138, 1.119, 1.1, 1.081, 1.063, 1.046, 1.03, 3.542e-05, 0.9143, 0.8546}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.766, 1.756, 1.746, 1.737, + 1.727, 1.717, 1.708, 1.699, 1.69, 1.681, 1.672, 1.663, 1.655, 1.646, 1.638, 1.629, 1.621, 1.613, 1.605, 1.597, 1.589, + 1.582, 1.574, 1.555, 1.537, 1.519, 1.502, 1.485, 1.469, 1.453, 1.437, 1.422, 1.407, 1.378, 1.351, 1.324, 1.299, 1.274, + 1.251, 1.229, 1.207, 1.186, 1.166, 1.146, 1.128, 1.109, 1.092, 3.542e-05, 0.9692, 0.9059}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.864, 1.854, 1.843, + 1.833, 1.823, 1.813, 1.803, 1.793, 1.784, 1.774, 1.765, 1.755, 1.746, 1.737, 1.729, 1.72, 1.711, 1.703, 1.694, 1.686, + 1.678, 1.669, 1.649, 1.63, 1.611, 1.593, 1.575, 1.557, 1.54, 1.524, 1.507, 1.492, 1.461, 1.432, 1.403, 1.377, 1.351, + 1.326, 1.302, 1.279, 1.257, 1.235, 1.215, 1.195, 1.175, 1.157, 3.542e-05, 1.027, 0.9597}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.967, 1.955, + 1.944, 1.933, 1.923, 1.912, 1.902, 1.891, 1.881, 1.871, 1.861, 1.852, 1.842, 1.833, 1.823, 1.814, 1.805, 1.796, 1.787, + 1.778, 1.77, 1.748, 1.728, 1.707, 1.688, 1.669, 1.65, 1.632, 1.614, 1.597, 1.58, 1.548, 1.516, 1.487, 1.458, 1.431, + 1.404, 1.379, 1.354, 1.331, 1.308, 1.286, 1.265, 1.245, 1.225, 3.542e-05, 1.087, 1.016}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.074, + 2.062, 2.05, 2.038, 2.027, 2.016, 2.005, 1.994, 1.983, 1.973, 1.962, 1.952, 1.942, 1.932, 1.922, 1.912, 1.903, 1.893, + 1.884, 1.875, 1.852, 1.83, 1.809, 1.788, 1.767, 1.748, 1.728, 1.709, 1.691, 1.673, 1.639, 1.605, 1.574, 1.543, 1.514, + 1.486, 1.459, 1.434, 1.409, 1.384, 1.361, 1.339, 1.317, 1.296, 3.542e-05, 1.15, 1.075}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.185, 2.172, 2.16, 2.148, 2.136, 2.124, 2.112, 2.101, + 2.09, 2.079, 2.068, 2.057, 2.046, 2.036, 2.025, 2.015, 2.005, 1.995, 1.985, 1.961, 1.937, 1.915, 1.892, 1.871, 1.85, 1.829, 1.809, + 1.79, 1.771, 1.734, 1.699, 1.665, 1.633, 1.602, 1.572, 1.544, 1.516, 1.49, 1.464, 1.44, 1.416, 1.393, 1.371, 3.542e-05, 1.216, 1.137}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 2.301, 2.288, 2.275, 2.262, 2.249, 2.237, 2.225, 2.213, 2.201, 2.189, 2.177, 2.166, 2.155, 2.144, 2.133, 2.122, + 2.111, 2.101, 2.075, 2.05, 2.026, 2.002, 1.979, 1.957, 1.935, 1.914, 1.893, 1.873, 1.834, 1.796, 1.761, 1.727, 1.694, + 1.662, 1.632, 1.603, 1.575, 1.548, 1.522, 1.497, 1.473, 1.449, 3.542e-05, 1.286, 1.201}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 2.422, 2.408, 2.394, 2.381, 2.367, 2.354, 2.341, 2.329, 2.316, 2.304, 2.292, 2.28, 2.268, 2.256, 2.245, + 2.233, 2.222, 2.195, 2.168, 2.142, 2.117, 2.093, 2.069, 2.046, 2.023, 2.001, 1.98, 1.938, 1.899, 1.861, 1.825, 1.79, + 1.757, 1.725, 1.694, 1.664, 1.635, 1.608, 1.581, 1.556, 1.531, 3.542e-05, 1.358, 1.269}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 2.548, 2.533, 2.519, 2.505, 2.491, 2.477, 2.463, 2.45, 2.437, 2.424, 2.411, 2.398, 2.386, 2.373, + 2.361, 2.349, 2.32, 2.292, 2.264, 2.238, 2.212, 2.186, 2.162, 2.138, 2.114, 2.091, 2.048, 2.006, 1.965, 1.927, 1.89, + 1.855, 1.821, 1.789, 1.757, 1.727, 1.698, 1.67, 1.642, 1.616, 3.542e-05, 1.433, 1.339}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 2.679, 2.664, 2.648, 2.633, 2.619, 2.604, 2.59, 2.576, 2.562, 2.548, 2.535, 2.522, 2.508, + 2.495, 2.483, 2.452, 2.421, 2.392, 2.364, 2.336, 2.309, 2.283, 2.258, 2.233, 2.209, 2.162, 2.117, 2.075, 2.034, 1.995, + 1.958, 1.922, 1.888, 1.854, 1.822, 1.792, 1.762, 1.733, 1.705, 3.542e-05, 1.512, 1.413}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 2.816, 2.8, 2.783, 2.768, 2.752, 2.737, 2.722, 2.707, 2.692, 2.678, 2.664, 2.65, + 2.636, 2.622, 2.589, 2.557, 2.526, 2.496, 2.466, 2.438, 2.41, 2.383, 2.357, 2.331, 2.282, 2.234, 2.189, 2.146, 2.105, + 2.066, 2.028, 1.991, 1.956, 1.922, 1.89, 1.858, 1.828, 1.799, 3.542e-05, 1.595, 1.490}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.958, 2.941, 2.924, 2.907, 2.891, 2.875, 2.859, 2.843, 2.828, 2.813, 2.798, + 2.783, 2.769, 2.733, 2.699, 2.666, 2.634, 2.603, 2.572, 2.543, 2.514, 2.486, 2.459, 2.407, 2.357, 2.309, 2.263, 2.22, + 2.178, 2.138, 2.099, 2.062, 2.026, 1.992, 1.959, 1.927, 1.896, 3.542e-05, 1.681, 1.570}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.106, 3.088, 3.07, 3.052, 3.035, 3.018, 3.001, 2.985, 2.969, 2.953, + 2.937, 2.922, 2.884, 2.848, 2.812, 2.778, 2.745, 2.713, 2.682, 2.651, 2.622, 2.593, 2.537, 2.484, 2.434, 2.386, 2.34, + 2.295, 2.253, 2.212, 2.173, 2.135, 2.099, 2.064, 2.03, 1.997, 3.542e-05, 1.77, 1.654}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.26, 3.24, 3.222, 3.203, 3.185, 3.167, 3.15, 3.132, 3.115, + 3.099, 3.082, 3.042, 3.003, 2.966, 2.929, 2.894, 2.86, 2.827, 2.794, 2.763, 2.732, 2.674, 2.618, 2.564, 2.513, 2.465, + 2.418, 2.373, 2.33, 2.289, 2.249, 2.21, 2.173, 2.138, 2.103, 3.542e-05, 1.864, 1.741}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 3.419, 3.399, 3.379, 3.36, 3.341, 3.322, 3.304, 3.286, 3.268, 3.25, 3.207, 3.166, 3.126, 3.087, 3.05, 3.014, 2.978, 2.944, + 2.911, 2.878, 2.816, 2.757, 2.7, 2.646, 2.595, 2.546, 2.498, 2.453, 2.409, 2.367, 2.326, 2.287, 2.25, 2.213, 3.542e-05, 1.961, 1.832}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 3.585, 3.564, 3.543, 3.523, 3.503, 3.483, 3.464, 3.445, 3.426, 3.38, 3.336, 3.294, 3.253, 3.213, 3.174, 3.137, 3.1, + 3.065, 3.031, 2.965, 2.902, 2.842, 2.785, 2.731, 2.679, 2.629, 2.581, 2.535, 2.49, 2.448, 2.406, 2.367, 2.328, 3.542e-05, 2.063, 1.926}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 3.758, 3.735, 3.713, 3.692, 3.671, 3.65, 3.63, 3.61, 3.561, 3.514, 3.469, 3.425, 3.383, 3.342, 3.302, 3.264, + 3.226, 3.19, 3.12, 3.054, 2.99, 2.93, 2.873, 2.818, 2.765, 2.714, 2.665, 2.619, 2.574, 2.53, 2.488, 2.448, 3.542e-05, 2.168, 2.025}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 3.937, 3.913, 3.89, 3.867, 3.845, 3.823, 3.802, 3.75, 3.7, 3.652, 3.605, 3.561, 3.517, 3.475, 3.434, + 3.394, 3.356, 3.282, 3.212, 3.145, 3.081, 3.02, 2.962, 2.907, 2.853, 2.802, 2.752, 2.705, 2.659, 2.615, 2.573, 3.542e-05, 2.278, 2.127}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 4.122, 4.097, 4.073, 4.049, 4.026, 4.003, 3.948, 3.895, 3.843, 3.794, 3.746, 3.7, 3.655, 3.612, + 3.57, 3.529, 3.451, 3.376, 3.306, 3.238, 3.174, 3.113, 3.054, 2.998, 2.944, 2.892, 2.842, 2.794, 2.747, 2.702, 3.542e-05, 2.392, 2.234}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.315, 4.289, 4.263, + 4.238, 4.214, 4.155, 4.098, 4.043, 3.991, 3.94, 3.891, 3.843, 3.797, 3.753, 3.709, 3.627, 3.548, 3.473, 3.402, 3.335, + 3.27, 3.208, 3.148, 3.091, 3.037, 2.984, 2.933, 2.884, 2.837, 3.542e-05, 2.511, 2.344}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.515, 4.487, 4.46, 4.434, 4.371, 4.31, 4.252, 4.196, 4.142, 4.09, 4.04, 3.991, + 3.944, 3.898, 3.81, 3.727, 3.648, 3.573, 3.501, 3.433, 3.368, 3.305, 3.245, 3.187, 3.132, 3.079, 3.027, 2.977, 3.542e-05, 2.635, 2.459}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.722, 4.693, 4.665, 4.597, 4.532, 4.47, 4.411, 4.353, 4.298, 4.244, 4.193, + 4.143, 4.094, 4.001, 3.913, 3.83, 3.751, 3.675, 3.603, 3.534, 3.468, 3.405, 3.344, 3.286, 3.23, 3.176, 3.123, 3.542e-05, 2.763, 2.579}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.936, 4.906, 4.833, 4.764, 4.698, 4.635, 4.574, 4.515, 4.458, 4.403, + 4.35, 4.298, 4.2, 4.107, 4.019, 3.935, 3.856, 3.78, 3.707, 3.638, 3.571, 3.507, 3.446, 3.387, 3.33, 3.275, 3.542e-05, 2.896, 2.703}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 5.159, 5.081, 5.007, 4.936, 4.868, 4.803, 4.741, 4.681, 4.622, 4.566, 4.512, 4.407, 4.309, 4.216, 4.128, 4.044, + 3.964, 3.887, 3.814, 3.744, 3.677, 3.612, 3.55, 3.49, 3.432, 3.542e-05, 3.035, 2.832}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.75, 5.662, 5.579, 5.499, 5.423, 5.35, 5.28, 5.212, + 5.147, 5.084, 4.964, 4.851, 4.744, 4.643, 4.547, 4.456, 4.369, 4.286, 4.206, 4.13, 4.056, 3.986, 3.918, 3.853, 3.542e-05, 3.404, 3.176}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 6.395, 6.296, 6.202, 6.112, 6.027, 5.945, 5.866, + 5.79, 5.717, 5.579, 5.449, 5.327, 5.211, 5.102, 4.998, 4.898, 4.804, 4.714, 4.627, 4.544, 4.464, 4.388, 4.314, 3.542e-05, 3.808, 3.552}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.098, 6.985, 6.879, 6.779, 6.683, 6.591, + 6.503, 6.418, 6.258, 6.108, 5.968, 5.836, 5.711, 5.593, 5.48, 5.373, 5.27, 5.172, 5.078, 4.988, 4.902, 4.819, 3.542e-05, 4.25, 3.962}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.861, 7.734, 7.615, 7.502, 7.395, + 7.292, 7.193, 7.008, 6.835, 6.674, 6.523, 6.38, 6.245, 6.118, 5.996, 5.88, 5.769, 5.663, 5.561, 5.464, 5.37, 3.542e-05, 4.732, 4.410}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8.69, 8.547, 8.413, 8.286, 8.166, 8.051, 7.835, 7.636, 7.451, 7.278, 7.115, + 6.961, 6.816, 6.678, 6.547, 6.421, 6.302, 6.187, 6.078, 5.972, 3.542e-05, 5.257, 4.897}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 9.588, 9.428, 9.277, + 9.135, 9.0, 8.749, 8.519, 8.305, 8.106, 7.92, 7.745, 7.58, 7.423, 7.275, 7.133, 6.998, 6.87, 6.746, 6.628, 3.542e-05, 5.827, 5.425}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.56, 10.38, + 10.21, 10.05, 9.759, 9.491, 9.244, 9.016, 8.803, 8.603, 8.415, 8.238, 8.069, 7.91, 7.758, 7.613, 7.474, 7.341, 3.542e-05, 6.445, 5.998}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 11.62, 11.41, 11.22, 10.88, 10.56, 10.28, 10.01, 9.769, + 9.541, 9.328, 9.126, 8.936, 8.756, 8.584, 8.421, 8.265, 8.116, 3.542e-05, 7.115, 6.618}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 12.75, 12.53, 12.11, 11.75, 11.41, 11.11, 10.83, 10.57, 10.32, 10.1, 9.88, 9.676, 9.483, 9.299, 9.124, 8.957, 3.542e-05, 7.84, 7.288}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 13.99, 13.49, 13.05, 12.67, 12.31, 11.99, 11.69, 11.41, 11.15, 10.91, 10.68, 10.46, 10.25, 10.06, 9.869, 3.542e-05, 8.623, 8.011}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 16.75, 16.12, 15.58, 15.1, 14.66, 14.26, 13.9, 13.56, 13.25, 12.95, 12.67, 12.41, 12.16, 11.93, 3.542e-05, 10.38, 9.628}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 19.97, 19.17, 18.49, 17.89, 17.36, 16.87, 16.43, 16.02, 15.64, 15.28, 14.95, 14.63, 14.34, 3.542e-05, 12.42, 11.5}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 23.71, 22.7, 21.85, 21.1, 20.45, 19.85, 19.31, 18.81, 18.35, 17.93, 17.53, 17.15, 3.542e-05, 14.77, 13.65}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 28.07, 26.78, 25.71, 24.79, 23.97, 23.25, 22.59, 21.99, 21.44, 20.93, 20.45, 3.542e-05, 17.48, 16.12}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 33.16, 31.5, 30.15, 29.0, 28.0, 27.11, 26.31, 25.59, 24.92, 24.31, 3.542e-05, 20.6, 18.94}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 39.13, 36.97, 35.25, 33.82, 32.58, 31.5, 30.53, 29.65, 28.86, 3.542e-05, 24.19, 22.16}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 46.17, 43.33, 41.13, 39.33, 37.8, 36.47, 35.29, 34.24, 3.542e-05, 28.31, 25.84}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 54.54, 50.75, 47.92, 45.65, 43.75, 42.11, 40.68, 3.542e-05, 33.07, 30.03}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 64.64, 59.47, 55.78, 52.9, 50.53, 48.51, 3.542e-05, 38.55, 34.81}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 77.05, 69.8, 64.93, 61.24, 58.27, 3.542e-05, 44.92, 40.28}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 92.76, 82.18, 75.63, 70.87, 3.542e-05, 52.35, 46.54}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 113.6, 97.22, 88.27, 3.542e-05, 61.12, 53.76}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 143.9, 115.8, 3.542e-05, 71.6, 62.15}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 201.8, 3.542e-05, 84.38, 71.99}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 148.4, 115.1}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 201.7, 144.2}, + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.542e-05, 270.9, 177.8}}}; #endif // UNUSED_FLUID_PROPS -} // namespace Fluid +} // namespace FluidProperties } // namespace EnergyPlus diff --git a/src/EnergyPlus/FluidProperties.hh b/src/EnergyPlus/FluidProperties.hh index c3a42ac9e40..8beb5eb006f 100644 --- a/src/EnergyPlus/FluidProperties.hh +++ b/src/EnergyPlus/FluidProperties.hh @@ -70,7 +70,7 @@ struct EnergyPlusData; namespace FluidProperties { #undef PERFORMANCE_OPT - + #ifdef EP_cache_GlycolSpecificHeat int constexpr t_sh_cache_size = 1024 * 1024; int constexpr t_sh_precision_bits = 24; @@ -94,141 +94,141 @@ namespace FluidProperties { SatSupDensityPress, Num }; - + struct RefrigProps { // Members - std::string Name; // Name of the refrigerant + std::string Name; // Name of the refrigerant int Num = 0; bool used = false; - std::string satTempArrayName; // Array of saturated temperature points, must be same for all properties - std::string supTempArrayName; // Array of superheated temperature points, must be same for all properties - - int NumPsPoints = 0; // Number of saturation pressure - Real64 PsLowTempValue = 0.0; // Low Temperature Value for Ps (>0.0) - Real64 PsHighTempValue = 0.0; // High Temperature Value for Ps (max in tables) - int PsLowTempIndex = 0; // Low Temperature Min Index for Ps (>0.0) - int PsHighTempIndex = 0; // High Temperature Max Index for Ps (>0.0) - Real64 PsLowPresValue = 0.0; // Low Pressure Value for Ps (>0.0) - Real64 PsHighPresValue = 0.0; // High Pressure Value for Ps (max in tables) - int PsLowPresIndex = 0; // Low Pressure Min Index for Ps (>0.0) - int PsHighPresIndex = 0; // High Pressure Max Index for Ps (>0.0) - Array1D PsTemps; // Temperatures for saturation pressures - Array1D PsValues; // Saturation pressures at PsTemps -#ifdef PERFORMANCE_OPT + std::string satTempArrayName; // Array of saturated temperature points, must be same for all properties + std::string supTempArrayName; // Array of superheated temperature points, must be same for all properties + + int NumPsPoints = 0; // Number of saturation pressure + Real64 PsLowTempValue = 0.0; // Low Temperature Value for Ps (>0.0) + Real64 PsHighTempValue = 0.0; // High Temperature Value for Ps (max in tables) + int PsLowTempIndex = 0; // Low Temperature Min Index for Ps (>0.0) + int PsHighTempIndex = 0; // High Temperature Max Index for Ps (>0.0) + Real64 PsLowPresValue = 0.0; // Low Pressure Value for Ps (>0.0) + Real64 PsHighPresValue = 0.0; // High Pressure Value for Ps (max in tables) + int PsLowPresIndex = 0; // Low Pressure Min Index for Ps (>0.0) + int PsHighPresIndex = 0; // High Pressure Max Index for Ps (>0.0) + Array1D PsTemps; // Temperatures for saturation pressures + Array1D PsValues; // Saturation pressures at PsTemps +#ifdef PERFORMANCE_OPT Array1D PsTempRatios; // PsTempRatios(i) = (PsValues(i+1) - PsValues(i)) / (PsTemps(i+1) - PsTemps(i)). Speed optimization. -#endif // PERFORMANCE_OPT - - int NumHPoints = 0; // Number of enthalpy points - Real64 HfLowTempValue = 0.0; // Low Temperature Value for Hf (>0.0) - Real64 HfHighTempValue = 0.0; // High Temperature Value for Hf (max in tables) - int HfLowTempIndex = 0; // Low Temperature Min Index for Hf (>0.0) - int HfHighTempIndex = 0; // High Temperature Max Index for Hf (>0.0) - Real64 HfgLowTempValue = 0.0; // Low Temperature Value for Hfg (>0.0) - Real64 HfgHighTempValue = 0.0; // High Temperature Value for Hfg (max in tables) - int HfgLowTempIndex = 0; // Low Temperature Min Index for Hfg (>0.0) - int HfgHighTempIndex = 0; // High Temperature Max Index for Hfg (>0.0) - Array1D HTemps; // Temperatures for enthalpy points - Array1D HfValues; // Enthalpy of saturated fluid at HTemps - Array1D HfgValues; // Enthalpy of saturated fluid/gas at HTemps -#ifdef PERFORMANCE_OPT +#endif // PERFORMANCE_OPT + + int NumHPoints = 0; // Number of enthalpy points + Real64 HfLowTempValue = 0.0; // Low Temperature Value for Hf (>0.0) + Real64 HfHighTempValue = 0.0; // High Temperature Value for Hf (max in tables) + int HfLowTempIndex = 0; // Low Temperature Min Index for Hf (>0.0) + int HfHighTempIndex = 0; // High Temperature Max Index for Hf (>0.0) + Real64 HfgLowTempValue = 0.0; // Low Temperature Value for Hfg (>0.0) + Real64 HfgHighTempValue = 0.0; // High Temperature Value for Hfg (max in tables) + int HfgLowTempIndex = 0; // Low Temperature Min Index for Hfg (>0.0) + int HfgHighTempIndex = 0; // High Temperature Max Index for Hfg (>0.0) + Array1D HTemps; // Temperatures for enthalpy points + Array1D HfValues; // Enthalpy of saturated fluid at HTemps + Array1D HfgValues; // Enthalpy of saturated fluid/gas at HTemps +#ifdef PERFORMANCE_OPT Array1D HfTempRatios; Array1D HfgTempRatios; -#endif // PERFORMANCE_OPT - - int NumCpPoints = 0; // Number of specific heat of fluid points - Real64 CpfLowTempValue = 0.0; // Low Temperature Value for Cpf (>0.0) - Real64 CpfHighTempValue = 0.0; // High Temperature Value for Cpf (max in tables) - int CpfLowTempIndex = 0; // Low Temperature Min Index for Cpf (>0.0) - int CpfHighTempIndex = 0; // High Temperature Max Index for Cpf (>0.0) - Real64 CpfgLowTempValue = 0.0; // Low Temperature Value for Cpfg (>0.0) - Real64 CpfgHighTempValue = 0.0; // High Temperature Value for Cpfg (max in tables) - int CpfgLowTempIndex = 0; // Low Temperature Min Index for Cpfg (>0.0) - int CpfgHighTempIndex = 0; // High Temperature Max Index for Cpfg (>0.0) - Array1D CpTemps; // Temperatures for specific heat points - Array1D CpfValues; // Specific heat of saturated fluid at CpTemps - Array1D CpfgValues; // Specific heat of saturated fluid/gas at CpTemps -#ifdef PERFORMANCE_OPT +#endif // PERFORMANCE_OPT + + int NumCpPoints = 0; // Number of specific heat of fluid points + Real64 CpfLowTempValue = 0.0; // Low Temperature Value for Cpf (>0.0) + Real64 CpfHighTempValue = 0.0; // High Temperature Value for Cpf (max in tables) + int CpfLowTempIndex = 0; // Low Temperature Min Index for Cpf (>0.0) + int CpfHighTempIndex = 0; // High Temperature Max Index for Cpf (>0.0) + Real64 CpfgLowTempValue = 0.0; // Low Temperature Value for Cpfg (>0.0) + Real64 CpfgHighTempValue = 0.0; // High Temperature Value for Cpfg (max in tables) + int CpfgLowTempIndex = 0; // Low Temperature Min Index for Cpfg (>0.0) + int CpfgHighTempIndex = 0; // High Temperature Max Index for Cpfg (>0.0) + Array1D CpTemps; // Temperatures for specific heat points + Array1D CpfValues; // Specific heat of saturated fluid at CpTemps + Array1D CpfgValues; // Specific heat of saturated fluid/gas at CpTemps +#ifdef PERFORMANCE_OPT Array1D CpfTempRatios; Array1D CpfgTempRatios; -#endif // PERFORMANCE_OPT - +#endif // PERFORMANCE_OPT + int NumRhoPoints = 0; // Number of density of fluid points - Real64 RhofLowTempValue = 0.0; // Low Temperature Value for Rhof (>0.0) - Real64 RhofHighTempValue = 0.0; // High Temperature Value for Rhof (max in tables) + Real64 RhofLowTempValue = 0.0; // Low Temperature Value for Rhof (>0.0) + Real64 RhofHighTempValue = 0.0; // High Temperature Value for Rhof (max in tables) int RhofLowTempIndex = 0; // Low Temperature Min Index for Rhof (>0.0) int RhofHighTempIndex = 0; // High Temperature Max Index for Rhof (>0.0) - Real64 RhofgLowTempValue = 0.0; // Low Temperature Value for Rhofg (>0.0) - Real64 RhofgHighTempValue = 0.0; // High Temperature Value for Rhofg (max in tables) + Real64 RhofgLowTempValue = 0.0; // Low Temperature Value for Rhofg (>0.0) + Real64 RhofgHighTempValue = 0.0; // High Temperature Value for Rhofg (max in tables) int RhofgLowTempIndex = 0; // Low Temperature Min Index for Rhofg (>0.0) int RhofgHighTempIndex = 0; // High Temperature Max Index for Rhofg (>0.0) - Array1D RhoTemps; // Temperatures for density of fluid points - Array1D RhofValues; // Density of saturated fluid at RhoTemps - Array1D RhofgValues; // Density of saturated fluid/gas at RhoTemps -#ifdef PERFORMANCE_OPT + Array1D RhoTemps; // Temperatures for density of fluid points + Array1D RhofValues; // Density of saturated fluid at RhoTemps + Array1D RhofgValues; // Density of saturated fluid/gas at RhoTemps +#ifdef PERFORMANCE_OPT Array1D RhofTempRatios; Array1D RhofgTempRatios; -#endif // PERFORMANCE_OPT - - int NumSupTempPoints = 0; // Number of temperature points for superheated enthalpy - int NumSupPressPoints = 0; // Number of pressure points for superheated enthalpy - Array1D SupTemps; // Temperatures for superheated gas - Array1D SupPress; // Pressures for superheated gas +#endif // PERFORMANCE_OPT + + int NumSupTempPoints = 0; // Number of temperature points for superheated enthalpy + int NumSupPressPoints = 0; // Number of pressure points for superheated enthalpy + Array1D SupTemps; // Temperatures for superheated gas + Array1D SupPress; // Pressures for superheated gas Array2D HshValues; // Enthalpy of superheated gas at HshTemps, HshPress Array2D RhoshValues; // Density of superheated gas at HshTemps, HshPress std::array errors; Real64 getQuality(EnergyPlusData &state, - Real64 Temperature, // actual temperature given as input - Real64 Enthalpy, // actual enthalpy given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + Real64 Temperature, // actual temperature given as input + Real64 Enthalpy, // actual enthalpy given as input + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSatPressure(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSatTemperature(EnergyPlusData &state, Real64 Pressure, // actual temperature given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSatEnthalpy(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Quality, // actual quality given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSatDensity(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Quality, // actual quality given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSatSpecificHeat(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Quality, // actual quality given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSupHeatEnthalpy(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Pressure, // actual pressure given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSupHeatPressure(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Enthalpy, // actual enthalpy given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getSupHeatTemp(EnergyPlusData &state, Real64 Pressure, // actual pressure given as input Real64 Enthalpy, // actual enthalpy given as input Real64 TempLow, // lower bound of temperature in the iteration Real64 TempUp, // upper bound of temperature in the iteration - std::string_view CalledFrom); // routine this function was called from (error messages) - + std::string_view CalledFrom); // routine this function was called from (error messages) + Real64 getSupHeatDensity(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input Real64 Pressure, // actual pressure given as input - std::string_view CalledFrom); // routine this function was called from (error messages) + std::string_view CalledFrom); // routine this function was called from (error messages) }; enum class GlycolError @@ -244,133 +244,133 @@ namespace FluidProperties { ViscosityHigh, Num }; - + struct GlycolRawProps { // Members - std::string Name; // Name of the glycol + std::string Name; // Name of the glycol int Num = 0; std::string CpTempArrayName; - bool CpDataPresent = false; // Flag set when specific heat data is available - int NumCpTempPoints = 0; // Number of temperature points for specific heat - int NumCpConcPoints = 0; // Number of concentration points for specific heat + bool CpDataPresent = false; // Flag set when specific heat data is available + int NumCpTempPoints = 0; // Number of temperature points for specific heat + int NumCpConcPoints = 0; // Number of concentration points for specific heat Array1D CpTemps; // Temperatures for specific heat of glycol Array1D CpConcs; // Concentration for specific heat of glycol Array2D CpValues; // Specific heat data values std::string RhoTempArrayName; - bool RhoDataPresent = false; // Flag set when density data is available - int NumRhoTempPoints = 0; // Number of temperature points for density - int NumRhoConcPoints = 0; // Number of concentration points for density - Array1D RhoTemps; // Temperatures for density of glycol - Array1D RhoConcs; // Concentration for density of glycol - Array2D RhoValues; // Density data values + bool RhoDataPresent = false; // Flag set when density data is available + int NumRhoTempPoints = 0; // Number of temperature points for density + int NumRhoConcPoints = 0; // Number of concentration points for density + Array1D RhoTemps; // Temperatures for density of glycol + Array1D RhoConcs; // Concentration for density of glycol + Array2D RhoValues; // Density data values std::string CondTempArrayName; - bool CondDataPresent = false; // Flag set when conductivity data is available - int NumCondTempPoints = 0; // Number of temperature points for conductivity - int NumCondConcPoints = 0; // Number of concentration points for conductivity - Array1D CondTemps; // Temperatures for conductivity of glycol - Array1D CondConcs; // Concentration for conductivity of glycol - Array2D CondValues; // conductivity values + bool CondDataPresent = false; // Flag set when conductivity data is available + int NumCondTempPoints = 0; // Number of temperature points for conductivity + int NumCondConcPoints = 0; // Number of concentration points for conductivity + Array1D CondTemps; // Temperatures for conductivity of glycol + Array1D CondConcs; // Concentration for conductivity of glycol + Array2D CondValues; // conductivity values std::string ViscTempArrayName; - bool ViscDataPresent = false; // Flag set when viscosity data is available - int NumViscTempPoints = 0; // Number of temperature points for viscosity - int NumViscConcPoints = 0; // Number of concentration points for viscosity - Array1D ViscTemps; // Temperatures for viscosity of glycol - Array1D ViscConcs; // Concentration for viscosity of glycol - Array2D ViscValues; // viscosity values + bool ViscDataPresent = false; // Flag set when viscosity data is available + int NumViscTempPoints = 0; // Number of temperature points for viscosity + int NumViscConcPoints = 0; // Number of concentration points for viscosity + Array1D ViscTemps; // Temperatures for viscosity of glycol + Array1D ViscConcs; // Concentration for viscosity of glycol + Array2D ViscValues; // viscosity values }; - struct GlycolProps + struct GlycolProps { // Members - std::string Name; // Name of the glycol mixture (used by other parts of code) + std::string Name; // Name of the glycol mixture (used by other parts of code) int Num = 0; bool used = false; - + std::string GlycolName; // Name of non-water fluid that is part of this mixture // (refers to ethylene glycol, propylene glycol, or user fluid) int BaseGlycolIndex = 0; // Index in user defined glycol data (>0 = index in raw data, // -1=propylene glycol, -2=ethylene glycol) - Real64 Concentration = 0.0; // Concentration (if applicable) - - bool CpDataPresent = false; // Flag set when specific heat data is available - Real64 CpLowTempValue = 0.0; // Low Temperature Value for Cp (>0.0) - Real64 CpHighTempValue = 0.0; // High Temperature Value for Cp (max in tables) - int CpLowTempIndex = 0; // Low Temperature Min Index for Cp (>0.0) - int CpHighTempIndex = 0; // High Temperature Max Index for Cp (>0.0) - int NumCpTempPoints = 0; // Number of temperature points for specific heat - Array1D CpTemps; // Temperatures for specific heat of glycol - Array1D CpValues; // Specific heat data values (J/kg-K) + Real64 Concentration = 0.0; // Concentration (if applicable) + + bool CpDataPresent = false; // Flag set when specific heat data is available + Real64 CpLowTempValue = 0.0; // Low Temperature Value for Cp (>0.0) + Real64 CpHighTempValue = 0.0; // High Temperature Value for Cp (max in tables) + int CpLowTempIndex = 0; // Low Temperature Min Index for Cp (>0.0) + int CpHighTempIndex = 0; // High Temperature Max Index for Cp (>0.0) + int NumCpTempPoints = 0; // Number of temperature points for specific heat + Array1D CpTemps; // Temperatures for specific heat of glycol + Array1D CpValues; // Specific heat data values (J/kg-K) #ifdef PERFORMANCE_OPT int LoCpTempIdxLast = 1; Array1D CpTempRatios; // Speed optimization -#endif // PERFORMANCE_OPT - - bool RhoDataPresent = false; // Flag set when density data is available - int NumRhoTempPoints = 0.0; // Number of temperature points for density - Real64 RhoLowTempValue = 0.0; // Low Temperature Value for Rho (>0.0) - Real64 RhoHighTempValue = 0.0; // High Temperature Value for Rho (max in tables) - int RhoLowTempIndex = 0; // Low Temperature Min Index for Rho (>0.0) - int RhoHighTempIndex = 0; // High Temperature Max Index for Rho (>0.0) - Array1D RhoTemps; // Temperatures for density of glycol - Array1D RhoValues; // Density data values (kg/m3) +#endif // PERFORMANCE_OPT + + bool RhoDataPresent = false; // Flag set when density data is available + int NumRhoTempPoints = 0.0; // Number of temperature points for density + Real64 RhoLowTempValue = 0.0; // Low Temperature Value for Rho (>0.0) + Real64 RhoHighTempValue = 0.0; // High Temperature Value for Rho (max in tables) + int RhoLowTempIndex = 0; // Low Temperature Min Index for Rho (>0.0) + int RhoHighTempIndex = 0; // High Temperature Max Index for Rho (>0.0) + Array1D RhoTemps; // Temperatures for density of glycol + Array1D RhoValues; // Density data values (kg/m3) #ifdef PERFORMANCE_OPT int LoRhoTempIdxLast = 1; Array1D RhoTempRatios; // Speed optimization -#endif // PERFORMANCE_OPT - - bool CondDataPresent = false; // Flag set when conductivity data is available - int NumCondTempPoints = 0; // Number of temperature points for conductivity - Real64 CondLowTempValue = 0.0; // Low Temperature Value for Cond (>0.0) - Real64 CondHighTempValue = 0.0; // High Temperature Value for Cond (max in tables) +#endif // PERFORMANCE_OPT + + bool CondDataPresent = false; // Flag set when conductivity data is available + int NumCondTempPoints = 0; // Number of temperature points for conductivity + Real64 CondLowTempValue = 0.0; // Low Temperature Value for Cond (>0.0) + Real64 CondHighTempValue = 0.0; // High Temperature Value for Cond (max in tables) int CondLowTempIndex = 0; // Low Temperature Min Index for Cond (>0.0) int CondHighTempIndex = 0; // High Temperature Max Index for Cond (>0.0) - Array1D CondTemps; // Temperatures for conductivity of glycol - Array1D CondValues; // conductivity values (W/m-K) + Array1D CondTemps; // Temperatures for conductivity of glycol + Array1D CondValues; // conductivity values (W/m-K) #ifdef PERFORMANCE_OPT int LoCondTempIdxLast = 1; Array1D CondTempRatios; // Speed optimization -#endif // PERFORMANCE_OPT - - bool ViscDataPresent = false; // Flag set when viscosity data is available - int NumViscTempPoints = 0; // Number of temperature points for viscosity - Real64 ViscLowTempValue = 0.0; // Low Temperature Value for Visc (>0.0) - Real64 ViscHighTempValue = 0.0; // High Temperature Value for Visc (max in tables) +#endif // PERFORMANCE_OPT + + bool ViscDataPresent = false; // Flag set when viscosity data is available + int NumViscTempPoints = 0; // Number of temperature points for viscosity + Real64 ViscLowTempValue = 0.0; // Low Temperature Value for Visc (>0.0) + Real64 ViscHighTempValue = 0.0; // High Temperature Value for Visc (max in tables) int ViscLowTempIndex = 0; // Low Temperature Min Index for Visc (>0.0) int ViscHighTempIndex = 0; // High Temperature Max Index for Visc (>0.0) - Array1D ViscTemps; // Temperatures for viscosity of glycol - Array1D ViscValues; // viscosity values (mPa-s) + Array1D ViscTemps; // Temperatures for viscosity of glycol + Array1D ViscValues; // viscosity values (mPa-s) #ifdef PERFORMANCE_OPT int LoViscTempIdxLast = 1; Array1D ViscTempRatios; -#endif // PERFORMANCE_OPT - +#endif // PERFORMANCE_OPT + std::array errors; #ifdef EP_cache_GlycolSpecificHeat Real64 getSpecificHeat_raw(EnergyPlusData &state, Real64 Temperature, // actual temperature given as input std::string_view CalledFrom // routine this function was called from (error messages) - ); + ); #endif Real64 getSpecificHeat(EnergyPlusData &state, - Real64 Temperature, // actual temperature given as input + Real64 Temperature, // actual temperature given as input std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getDensity(EnergyPlusData &state, - Real64 Temperature, // actual temperature given as input + Real64 Temperature, // actual temperature given as input std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getConductivity(EnergyPlusData &state, - Real64 Temperature, // actual temperature given as input + Real64 Temperature, // actual temperature given as input std::string_view CalledFrom); // routine this function was called from (error messages) Real64 getViscosity(EnergyPlusData &state, - Real64 Temperature, // actual temperature given as input + Real64 Temperature, // actual temperature given as input std::string_view CalledFrom); // routine this function was called from (error messages) }; @@ -532,15 +532,15 @@ namespace FluidProperties { return Xhi - (((Thi - Tact) / (Thi - Tlo)) * (Xhi - Xlo)); } - int GetRefrigNum(EnergyPlusData &state, std::string_view name); + int GetRefrigNum(EnergyPlusData &state, std::string_view name); RefrigProps *GetRefrig(EnergyPlusData &state, std::string_view name); - - int GetGlycolRawNum(EnergyPlusData &state, std::string_view name); - GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view name); - int GetGlycolNum(EnergyPlusData &state, std::string_view name); - GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view name); - + int GetGlycolRawNum(EnergyPlusData &state, std::string_view name); + GlycolRawProps *GetGlycolRaw(EnergyPlusData &state, std::string_view name); + + int GetGlycolNum(EnergyPlusData &state, std::string_view name); + GlycolProps *GetGlycol(EnergyPlusData &state, std::string_view name); + std::string GetGlycolNameByIndex(EnergyPlusData &state, int Idx); // carries in substance index int FindArrayIndex(Real64 Value, // Value to be placed/found within the array of values @@ -565,7 +565,7 @@ namespace FluidProperties { ); bool CheckFluidPropertyName(EnergyPlusData &state, - std::string const &NameToCheck); // Name from input(?) to be checked against valid FluidPropertyNames + std::string const &NameToCheck); // Name from input(?) to be checked against valid FluidPropertyNames void ReportOrphanFluids(EnergyPlusData &state); @@ -603,21 +603,21 @@ namespace FluidProperties { Real64 superHeatedDensity(EnergyPlusData &state, Real64 temperature, Real64 pressure); }; -} // namespace Fluid +} // namespace FluidProperties struct FluidData : BaseGlobalStruct { bool DebugReportGlycols = false; bool DebugReportRefrigerants = false; - int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called + int GlycolErrorLimitTest = 1; // how many times error is printed with details before recurring called int RefrigErrorLimitTest = 1; // how many times error is printed with details before recurring called - Array1D refrigs; - Array1D glycolsRaw; - Array1D glycols; + Array1D refrigs; + Array1D glycolsRaw; + Array1D glycols; std::array glycolErrorLimits = {0, 0, 0, 0, 0, 0, 0, 0}; - + int SatErrCountGetSupHeatEnthalpyRefrig = 0; int SatErrCountGetSupHeatDensityRefrig = 0; int TempLoRangeErrIndexGetQualityRefrig = 0; @@ -637,10 +637,13 @@ struct FluidData : BaseGlobalStruct void clear_state() override { - for (int i = 1; i <= refrigs.isize(); ++i) delete refrigs(i); - for (int i = 1; i <= glycolsRaw.isize(); ++i) delete glycolsRaw(i); - for (int i = 1; i <= glycols.isize(); ++i) delete glycols(i); - + for (int i = 1; i <= refrigs.isize(); ++i) + delete refrigs(i); + for (int i = 1; i <= glycolsRaw.isize(); ++i) + delete glycolsRaw(i); + for (int i = 1; i <= glycols.isize(); ++i) + delete glycols(i); + new (this) FluidData(); } }; diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index 50b61cac8c2..7d70ed831e6 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -1268,10 +1268,10 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond) vrf.WaterCondenserMassFlow = state.dataLoopNodes->Node(vrf.CondenserNodeNum).MassFlowRate; CpCond = FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidName, - vrf.CondenserInletTemp, - state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidIndex, - RoutineName); + state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidName, + vrf.CondenserInletTemp, + state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).FluidIndex, + RoutineName); if (CondWaterMassFlow > 0.0) { CondOutletTemp = vrf.QCondenser / (CondWaterMassFlow * CpCond) + CondInletTemp; } else { @@ -2454,7 +2454,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; - + GlobalNames::VerifyUniqueInterObjectName( state, state.dataHVACVarRefFlow->VrfUniqueNames, cAlphaArgs(1), cCurrentModuleObject, cAlphaFieldNames(1), ErrorsFound); @@ -2491,7 +2491,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(4), cAlphaArgs(4)); ErrorsFound = true; } - + thisVrfFluidCtrl.RatedEvapCapacity = rNumericArgs(1); thisVrfFluidCtrl.RatedCompPowerPerCapcity = rNumericArgs(2); thisVrfFluidCtrl.RatedCompPower = thisVrfFluidCtrl.RatedCompPowerPerCapcity * thisVrfFluidCtrl.RatedEvapCapacity; @@ -2848,7 +2848,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound) cNumericFieldNames); ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)}; - + GlobalNames::VerifyUniqueInterObjectName( state, state.dataHVACVarRefFlow->VrfUniqueNames, cAlphaArgs(1), cCurrentModuleObject, cAlphaFieldNames(1), ErrorsFound); @@ -5656,11 +5656,12 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound); if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) { - rho = FluidProperties::GetDensityGlycol(state, - state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidName, - Constant::HWInitConvTemp, - state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidIndex, - RoutineName); + rho = FluidProperties::GetDensityGlycol( + state, + state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidName, + Constant::HWInitConvTemp, + state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum).FluidIndex, + RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow * rho; } @@ -6268,11 +6269,12 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state.dataHVACVarRefFlow->MyEnvrnFlag(VRFTUNum) = false; if (state.dataHVACVarRefFlow->VRF(VRFCond).CondenserType == DataHeatBalance::RefrigCondenserType::Water) { - rho = FluidProperties::GetDensityGlycol(state, - state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, - Constant::CWInitConvTemp, - state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, - RoutineName); + rho = + FluidProperties::GetDensityGlycol(state, + state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, + Constant::CWInitConvTemp, + state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, + RoutineName); state.dataHVACVarRefFlow->VRF(VRFCond).WaterCondenserDesignMassFlow = state.dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate * rho; InitComponentNodes(state, @@ -11337,8 +11339,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) this->RatedCompPower * CurveValue(state, this->OUCoolingPWRFT(NumOfCompSpdInput), this->CondensingTemp, this->IUEvaporatingTemp); // Initialization for h_IU_evap_in iterations (Label12) - h_IU_evap_in_low = this->refrig->getSatEnthalpy(state, OutdoorDryBulb - this->SC, 0.0, RoutineName); // Tc = Tamb - h_IU_evap_in_up = this->refrig->getSatEnthalpy(state, CapMaxTc - this->SC, 0.0, RoutineName); // Tc = CapMaxTc + h_IU_evap_in_low = this->refrig->getSatEnthalpy(state, OutdoorDryBulb - this->SC, 0.0, RoutineName); // Tc = Tamb + h_IU_evap_in_up = this->refrig->getSatEnthalpy(state, CapMaxTc - this->SC, 0.0, RoutineName); // Tc = CapMaxTc h_IU_evap_in = this->refrig->getSatEnthalpy(state, OutdoorDryBulb + 10 - this->SC, 0.0, RoutineName); // Tc = Tamb+10 NumIteHIUIn = 1; @@ -11357,7 +11359,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) TU_CoolingLoad = CompEvaporatingCAPSpdMax; this->TUCoolingLoad = TU_CoolingLoad; RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); - h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), RoutineName); + h_IU_evap_out = + this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); @@ -11369,10 +11372,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex; RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); - h_IU_evap_out_i = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), - max(min(Pevap, RefPHigh), RefPLow), - RoutineName); + h_IU_evap_out_i = + this->refrig->getSupHeatEnthalpy(state, + max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), + max(min(Pevap, RefPHigh), RefPLow), + RoutineName); if (h_IU_evap_out_i > h_IU_evap_in) { m_ref_IU_evap_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) <= 0.0) @@ -11390,10 +11394,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) SH_IU_merged = SH_IU_merged / m_ref_IU_evap; } else { RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); - h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, this->IUEvaporatingTemp + 3), - max(min(Pevap, RefPHigh), RefPLow), - RoutineName); + h_IU_evap_out = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); } @@ -11406,12 +11408,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Psuction = Pevap - Pipe_DeltP_c; // This Psuction is used for rps > min; will be updated for rps = min // Perform iteration to calculate T_comp_in - T_comp_in = this->refrig->getSupHeatTemp(state, - max(min(Pevap - Pipe_DeltP_c, RefPHigh), RefPLow), - h_comp_in, - Tsuction + 3, - Tsuction + 30, - RoutineName); + T_comp_in = this->refrig->getSupHeatTemp( + state, max(min(Pevap - Pipe_DeltP_c, RefPHigh), RefPLow), h_comp_in, Tsuction + 3, Tsuction + 30, RoutineName); SH_Comp = T_comp_in - Tsuction; // This is used for rps > min; will be updated for rps = min Q_c_TU_PL = TU_CoolingLoad + Pipe_Q_c; @@ -11549,11 +11547,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (Q_h_TU_PL > CompEvaporatingCAPSpdMax + CompEvaporatingPWRSpdMax) { // Required load is beyond the max system capacity - h_IU_cond_out = this->refrig->getSatEnthalpy( - state, - this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, - 0.0, - RoutineName); // Quality=0 + h_IU_cond_out = + this->refrig->getSatEnthalpy(state, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, + 0.0, + RoutineName); // Quality=0 h_IU_cond_out_ave = h_IU_cond_out; SC_IU_merged = 5; m_ref_IU_cond = TU_HeatingLoad / (h_IU_cond_in - h_IU_cond_out); @@ -11563,12 +11561,12 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) { TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex; - h_IU_cond_out_i = this->refrig->getSatEnthalpy( - state, - this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - - state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, - 0.0, - RoutineName); // Quality=0 + h_IU_cond_out_i = + this->refrig->getSatEnthalpy(state, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - + state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, + 0.0, + RoutineName); // Quality=0 m_ref_IU_cond_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) <= 0.0) ? 0.0 @@ -11582,11 +11580,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_cond_out_ave = h_IU_cond_out_ave / m_ref_IU_cond; // h_merge SC_IU_merged = SC_IU_merged / m_ref_IU_cond; } else { - h_IU_cond_out_ave = this->refrig->getSatEnthalpy( - state, - this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, - 0.0, - RoutineName); // Quality=0 + h_IU_cond_out_ave = + this->refrig->getSatEnthalpy(state, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, + 0.0, + RoutineName); // Quality=0 SC_IU_merged = 5; m_ref_IU_cond = TU_HeatingLoad / (h_IU_cond_in - h_IU_cond_out_ave); } @@ -11610,8 +11608,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // *Calculate capacity modification factor RefTSat = this->refrig->getSatTemperature(state, max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); - h_comp_in = this->refrig->getSupHeatEnthalpy( - state, max(RefTSat, CapMinTe + this->SH), max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); + h_comp_in = this->refrig->getSupHeatEnthalpy(state, max(RefTSat, CapMinTe + this->SH), max(min(CapMinPe, RefPHigh), RefPLow), RoutineName); C_cap_operation = this->VRFOU_CapModFactor(state, h_comp_in, h_IU_cond_out_ave, @@ -11707,10 +11704,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) // Update h_comp_out in iteration Label23 P_comp_in = this->refrig->getSatPressure(state, this->EvaporatingTemp, RoutineName); RefTSat = this->refrig->getSatTemperature(state, max(min(P_comp_in, RefPHigh), RefPLow), RoutineName); - h_comp_in_new = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, this->SH + this->EvaporatingTemp), - max(min(P_comp_in, RefPHigh), RefPLow), - RoutineName); + h_comp_in_new = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, this->SH + this->EvaporatingTemp), max(min(P_comp_in, RefPHigh), RefPLow), RoutineName); h_comp_out_new = Ncomp_new / m_ref_IU_cond + h_comp_in_new; if ((std::abs(h_comp_out - h_comp_out_new) > Tolerance * h_comp_out) && (h_IU_cond_in < h_IU_cond_in_up)) { @@ -11781,8 +11776,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) Pcond = this->refrig->getSatPressure(state, this->IUCondensingTemp, RoutineName); Real64 Pcond_temp = this->refrig->getSatPressure(state, 40.0, RoutineName); RefTSat = this->refrig->getSatTemperature(state, Pcond_temp, RoutineName); - h_IU_cond_in_up = this->refrig->getSupHeatEnthalpy( - state, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond_temp, RoutineName); + h_IU_cond_in_up = + this->refrig->getSupHeatEnthalpy(state, max(RefTSat, min(this->IUCondensingTemp + 50, RefTHigh)), Pcond_temp, RoutineName); h_IU_cond_in_low = this->refrig->getSatEnthalpy(state, this->IUCondensingTemp, 1.0, RoutineName); // Quality=1 h_IU_cond_in = h_IU_cond_in_low; } @@ -11797,12 +11792,12 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) { TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU); HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex; - h_IU_cond_out_i = this->refrig->getSatEnthalpy( - state, - this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - - state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, - 0.0, - RoutineName); // Quality=0 + h_IU_cond_out_i = + this->refrig->getSatEnthalpy(state, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - + state.dataDXCoils->DXCoil(HeatCoilIndex).ActualSC, + 0.0, + RoutineName); // Quality=0 m_ref_IU_cond_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) <= 0.0) ? 0.0 @@ -11816,11 +11811,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) h_IU_cond_out_ave = h_IU_cond_out_ave / m_ref_IU_cond; SC_IU_merged = SC_IU_merged / m_ref_IU_cond; } else { - h_IU_cond_out_ave = this->refrig->getSatEnthalpy( - state, - this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, - 0.0, - RoutineName); // Quality=0 + h_IU_cond_out_ave = + this->refrig->getSatEnthalpy(state, + this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) - 5.0, + 0.0, + RoutineName); // Quality=0 SC_IU_merged = 5; m_ref_IU_cond = TU_HeatingLoad / (h_IU_cond_in - h_IU_cond_out_ave); } @@ -11843,10 +11838,11 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex; RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); - h_IU_evap_out_i = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), - max(min(Pevap, RefPHigh), RefPLow), - RoutineName); + h_IU_evap_out_i = + this->refrig->getSupHeatEnthalpy(state, + max(RefTSat, this->IUEvaporatingTemp + state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH), + max(min(Pevap, RefPHigh), RefPLow), + RoutineName); if (h_IU_evap_out_i > h_IU_evap_in) { m_ref_IU_evap_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) <= 0.0) @@ -11864,10 +11860,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state) SH_IU_merged = SH_IU_merged / m_ref_IU_evap; } else { RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName); - h_IU_evap_out = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, this->IUEvaporatingTemp + 3), - max(min(Pevap, RefPHigh), RefPLow), - RoutineName); + h_IU_evap_out = + this->refrig->getSupHeatEnthalpy(state, max(RefTSat, this->IUEvaporatingTemp + 3), max(min(Pevap, RefPHigh), RefPLow), RoutineName); SH_IU_merged = 3; m_ref_IU_evap = TU_CoolingLoad / (h_IU_evap_out - h_IU_evap_in); } @@ -13557,9 +13551,9 @@ Label11:; RefTSat = this->refrig->getSatTemperature(state, Pe_update, RoutineName); Pipe_h_IU_out_i = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, Te_update + SH_IU_update), - Pe_update, - RoutineName); // hB_i for the IU + max(RefTSat, Te_update + SH_IU_update), + Pe_update, + RoutineName); // hB_i for the IU if (Pipe_h_IU_out_i > Pipe_h_IU_in) { Pipe_m_ref_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) <= 0.0) @@ -13661,12 +13655,7 @@ void VRFCondenserEquipment::VRFOU_CompSpd( // variable initializations: system operational parameters P_suction = this->refrig->getSatPressure(state, T_suction, RoutineName); - T_comp_in = this->refrig->getSupHeatTemp(state, - max(min(P_suction, RefPHigh), RefPLow), - h_comp_in, - T_suction + 3, - T_suction + 30, - RoutineName); + T_comp_in = this->refrig->getSupHeatTemp(state, max(min(P_suction, RefPHigh), RefPLow), h_comp_in, T_suction + 3, T_suction + 30, RoutineName); SH_Comp = T_comp_in - T_suction; // Calculate capacity modification factor @@ -13843,12 +13832,7 @@ void VRFCondenserEquipment::VRFOU_CompCap( // variable initializations: system operational parameters P_suction = this->refrig->getSatPressure(state, T_suction, RoutineName); - T_comp_in = this->refrig->getSupHeatTemp(state, - max(min(P_suction, RefPHigh), RefPLow), - h_comp_in, - T_suction + 3, - T_suction + 30, - RoutineName); + T_comp_in = this->refrig->getSupHeatTemp(state, max(min(P_suction, RefPHigh), RefPLow), h_comp_in, T_suction + 3, T_suction + 30, RoutineName); SH_Comp = T_comp_in - T_suction; // Calculate capacity modification factor @@ -14061,10 +14045,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, (2 * this->C3Te); RefTSat = this->refrig->getSatTemperature(state, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); - Pipe_h_IU_out_i = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, Pipe_Te_assumed + Modifi_SHin), - max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), - RoutineName); + Pipe_h_IU_out_i = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, Pipe_Te_assumed + Modifi_SHin), max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); if (Pipe_h_IU_out_i > Pipe_h_IU_in) { Pipe_m_ref_i = (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) <= 0.0) @@ -14083,10 +14065,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, } else { Pipe_SH_merged = this->SH; RefTSat = this->refrig->getSatTemperature(state, max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); - Pipe_h_IU_out = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, Pipe_Te_assumed + Pipe_SH_merged), - max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), - RoutineName); + Pipe_h_IU_out = this->refrig->getSupHeatEnthalpy( + state, max(RefTSat, Pipe_Te_assumed + Pipe_SH_merged), max(min(Pipe_Pe_assumed, RefPHigh), RefPLow), RoutineName); } // Re-calculate piping loss @@ -14119,12 +14099,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state, } // Perform iteration to calculate Pipe_T_comp_in( Te'+SH' ) - Pipe_T_comp_in = this->refrig->getSupHeatTemp(state, - max(min(Pipe_Pe_assumed - Pipe_DeltP, RefPHigh), RefPLow), - Pipe_h_comp_in, - T_suction + 3, - T_suction + 30, - RoutineName); + Pipe_T_comp_in = this->refrig->getSupHeatTemp( + state, max(min(Pipe_Pe_assumed - Pipe_DeltP, RefPHigh), RefPLow), Pipe_h_comp_in, T_suction + 3, T_suction + 30, RoutineName); Modifi_SH = Pipe_T_comp_in - T_suction; P_suction = Pipe_Pe_assumed - Pipe_DeltP; @@ -14266,10 +14242,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( // Calculate capacity modification factor MinOutdoorUnitPe = this->refrig->getSatPressure(state, T_suction, RoutineName); RefTSat = this->refrig->getSatTemperature(state, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RoutineName); - Pipe_h_comp_in = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, T_suction + this->SH), - max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), - RoutineName); + Pipe_h_comp_in = + this->refrig->getSupHeatEnthalpy(state, max(RefTSat, T_suction + this->SH), max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), RoutineName); C_cap_operation = this->VRFOU_CapModFactor( state, Pipe_h_comp_in, Pipe_h_out_ave, max(min(MinOutdoorUnitPe, RefPHigh), RefPLow), T_suction + this->SH, T_suction + 8, IUMaxCondTemp - 5); @@ -14332,10 +14306,8 @@ void VRFCondenserEquipment::VRFOU_CalcCompH( // Calculate capacity modification factor RefTSat = this->refrig->getSatTemperature(state, max(min(Modifi_Pe, RefPHigh), RefPLow), RoutineName); - Pipe_h_comp_in = this->refrig->getSupHeatEnthalpy(state, - max(RefTSat, T_suction + Modifi_SH), - max(min(Modifi_Pe, RefPHigh), RefPLow), - RoutineName); + Pipe_h_comp_in = + this->refrig->getSupHeatEnthalpy(state, max(RefTSat, T_suction + Modifi_SH), max(min(Modifi_Pe, RefPHigh), RefPLow), RoutineName); C_cap_operation = this->VRFOU_CapModFactor(state, Pipe_h_comp_in, Pipe_h_out_ave, @@ -14851,11 +14823,11 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( using General::SolveRoot; - int TUListNum; // index to TU List - int TUIndex; // Index to terminal unit - int CoilIndex; // index to coil in terminal unit - int NumTUInList; // number of terminal units is list - int NumIUActivated; // number of the used indoor units [-] + int TUListNum; // index to TU List + int TUIndex; // Index to terminal unit + int CoilIndex; // index to coil in terminal unit + int NumTUInList; // number of terminal units is list + int NumIUActivated; // number of the used indoor units [-] Real64 Pipe_v_ref; // Piping Loss Algorithm Parameter: Refrigerant velocity [m/s] Real64 Pipe_T_room; // Piping Loss Algorithm Parameter: Average Room Temperature [C] @@ -14917,28 +14889,20 @@ void VRFCondenserEquipment::VRFOU_PipeLossC( if (Pipe_viscosity_ref <= 0) Pipe_viscosity_ref = 16.26; // default superheated vapor viscosity data (MuPa*s) at T=353.15 K, P=2MPa Pipe_v_ref = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaSuc) * 0.25) / - this->refrig->getSupHeatDensity(state, - this->EvaporatingTemp + Pipe_SH_merged, - max(min(Pevap, RefPHigh), RefPLow), - RoutineName); + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), RoutineName); Pipe_Num_Re = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaSuc) * 0.25) * this->RefPipDiaSuc / Pipe_viscosity_ref * 1000000; Pipe_Num_Pr = Pipe_viscosity_ref * Pipe_cp_ref * 0.001 / Pipe_conductivity_ref; Pipe_Num_Nu = 0.023 * std::pow(Pipe_Num_Re, 0.8) * std::pow(Pipe_Num_Pr, 0.3); Pipe_Num_St = Pipe_Num_Nu / Pipe_Num_Re / Pipe_Num_Pr; - Pipe_DeltP = max(0.0, - 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaSuc * - this->refrig->getSupHeatDensity(state, - this->EvaporatingTemp + Pipe_SH_merged, - max(min(Pevap, RefPHigh), RefPLow), - RoutineName) * - pow_2(Pipe_v_ref) / 2 - - this->RefPipHei * - this->refrig->getSupHeatDensity(state, - this->EvaporatingTemp + Pipe_SH_merged, - max(min(Pevap, RefPHigh), RefPLow), - RoutineName) * - 9.80665); + Pipe_DeltP = max( + 0.0, + 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaSuc * + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), RoutineName) * + pow_2(Pipe_v_ref) / 2 - + this->RefPipHei * + this->refrig->getSupHeatDensity(state, this->EvaporatingTemp + Pipe_SH_merged, max(min(Pevap, RefPHigh), RefPLow), RoutineName) * + 9.80665); Pipe_Coe_k1 = Pipe_Num_Nu * Pipe_viscosity_ref; Pipe_Coe_k3 = RefPipInsH * (this->RefPipDiaSuc + 2 * this->RefPipInsThi); @@ -14988,11 +14952,11 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( using General::SolveRoot; - int TUListNum; // index to TU List - int TUIndex; // Index to terminal unit - int CoilIndex; // index to coil in terminal unit - int NumTUInList; // number of terminal units is list - int NumIUActivated; // number of the used indoor units [-] + int TUListNum; // index to TU List + int TUIndex; // Index to terminal unit + int CoilIndex; // index to coil in terminal unit + int NumTUInList; // number of terminal units is list + int NumIUActivated; // number of the used indoor units [-] Real64 Pipe_v_ref; // Piping Loss Algorithm Parameter: Refrigerant velocity [m/s] Real64 Pipe_T_room; // Piping Loss Algorithm Parameter: Average Room Temperature [C] @@ -15029,11 +14993,11 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( // Perform iteration to calculate Pipe_T_IU_in, given P and h Pipe_T_IU_in = this->refrig->getSupHeatTemp(state, - max(min(Pcond, RefPHigh), RefPLow), - Pipe_h_IU_in, - max(this->IUCondensingTemp, RefTSat), - min(this->IUCondensingTemp + 50, RefTHigh), - RoutineName); + max(min(Pcond, RefPHigh), RefPLow), + Pipe_h_IU_in, + max(this->IUCondensingTemp, RefTSat), + min(this->IUCondensingTemp + 50, RefTHigh), + RoutineName); Pipe_T_IU_in = min(RefTHigh, Pipe_T_IU_in); // Calculate average room temperature @@ -15063,9 +15027,8 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( 218.48 * Ref_Coe_v2 * Ref_Coe_v3 + 21.58; if (Pipe_viscosity_ref <= 0) Pipe_viscosity_ref = 16.26; // default superheated vapor viscosity data (MuPa*s) at T=353.15 K, P=2MPa - Pipe_v_ref = - Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaDis) * 0.25) / - this->refrig->getSupHeatDensity(state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName); + Pipe_v_ref = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaDis) * 0.25) / + this->refrig->getSupHeatDensity(state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName); Pipe_Num_Re = Pipe_m_ref / (Constant::Pi * pow_2(this->RefPipDiaDis) * 0.25) * this->RefPipDiaDis / Pipe_viscosity_ref * 1000000; Pipe_Num_Pr = Pipe_viscosity_ref * Pipe_cp_ref * 0.001 / Pipe_conductivity_ref; Pipe_Num_Nu = 0.023 * std::pow(Pipe_Num_Re, 0.8) * std::pow(Pipe_Num_Pr, 0.4); @@ -15078,15 +15041,11 @@ void VRFCondenserEquipment::VRFOU_PipeLossH( Pipe_Q = max(0.0, (Constant::Pi * this->RefPipLen) * (Pipe_T_IU_in - OutdoorDryBulb / 2 - Pipe_T_room / 2) / (1 / Pipe_Coe_k1 + 1 / Pipe_Coe_k2 + 1 / Pipe_Coe_k3)); // [W] - Pipe_DeltP = max(0.0, - 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaDis * - this->refrig->getSupHeatDensity( - state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * - pow_2(Pipe_v_ref) / 2 - - this->RefPipHei * - this->refrig->getSupHeatDensity( - state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * - 9.80665); + Pipe_DeltP = max( + 0.0, + 8 * Pipe_Num_St * std::pow(Pipe_Num_Pr, 0.6667) * this->RefPipEquLen / this->RefPipDiaDis * + this->refrig->getSupHeatDensity(state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * pow_2(Pipe_v_ref) / 2 - + this->RefPipHei * this->refrig->getSupHeatDensity(state, Pipe_T_IU_in, max(min(Pcond, RefPHigh), RefPLow), RoutineName) * 9.80665); Pipe_h_comp_out = Pipe_h_IU_in + Pipe_Q / Pipe_m_ref; diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh index b1448855c2b..5f2e1024827 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh @@ -320,47 +320,47 @@ namespace HVACVariableRefrigerantFlow { int HeatEIRFPLRErrorIndex = 0; // warning message index int CoolEIRFPLRErrorIndex = 0; // warning message index // The following are for the Algorithm Type: VRF model based on physics, applicable for Fluid Temperature Control - int AlgorithmIUCtrl; // VRF indoor unit contrl algorithm, 1-High sensible, 2-Te/Tc constant - Array1D CompressorSpeed; // compressor speed array [rps] - Real64 CondensingTemp; // VRV system outdoor unit condensing temperature [C] - Real64 CondTempFixed; // Inddor unit condensing temperature, fixed, for AlgorithmIUCtrl is 2-Te/Tc constant [C] - Real64 CoffEvapCap; // Evaporative Capacity Correction Factor - Real64 CompActSpeed; // Compressor speed [rps] - Real64 CompMaxDeltaP; // maximum compressor pressure rise [Pa] - Real64 C1Te; // VRF Outdoor Unit Coefficient 1 to calculate Te,req [--] - Real64 C2Te; // VRF Outdoor Unit Coefficient 2 to calculate Te,req [--] - Real64 C3Te; // VRF Outdoor Unit Coefficient 3 to calculate Te,req [--] - Real64 C1Tc; // VRF Outdoor Unit Coefficient 1 to calculate Tc,req [--] - Real64 C2Tc; // VRF Outdoor Unit Coefficient 2 to calculate Tc,req [--] - Real64 C3Tc; // VRF Outdoor Unit Coefficient 3 to calculate Tc,req [--] - Real64 DiffOUTeTo; // Difference between Outdoor Unit Te and OAT during Simultaneous Heating and Cooling operations - Real64 EffCompInverter; // Compressor Inverter Efficiency - Real64 EvaporatingTemp; // VRV system outdoor unit evaporating temperature [C] - Real64 EvapTempFixed; // Indoor unit evaporating temperature, fixed, for AlgorithmIUCtrl is 2-Te/Tc constant [C] - Real64 HROUHexRatio; // HR OU Heat Exchanger Capacity Ratio [--] - Real64 IUEvaporatingTemp; // VRV system indoor unit evaporating temperature, min among all indoor units [C] - Real64 IUCondensingTemp; // VRV system indoor unit condensing temperature, max among all indoor units [C] - Real64 IUEvapTempLow; // VRV system indoor unit evaporating temperature, lower bound[C] - Real64 IUEvapTempHigh; // VRV system indoor unit evaporating temperature, higher bound [C] - Real64 IUCondTempLow; // VRV system indoor unit condensing temperature, lower bound [C] - Real64 IUCondTempHigh; // VRV system indoor unit condensing temperature, higher bound [C] - Real64 IUCondHeatRate; // Indoor Unit Condensers Total Heat Release Rate, excluding piping loss [W] - Real64 IUEvapHeatRate; // Outdoor Unit Evaporators Total Heat Extract Rate, excluding piping loss [W] - Real64 Ncomp; // compressor electric power [W] - Real64 NcompCooling; // compressor electric power at cooling mode [W] - Real64 NcompHeating; // compressor electric power at heating mode [W] - Array1D_int OUCoolingCAPFT; // index to outdoor unit cooling capacity function of temperature at different compressor speed - Array1D_int OUCoolingPWRFT; // index to outdoor unit cooling power function of temperature at different compressor speed - Real64 OUEvapTempLow; // VRV system outdoor unit evaporating temperature, lower bound[C] - Real64 OUEvapTempHigh; // VRV system outdoor unit evaporating temperature, higher bound [C] - Real64 OUCondTempLow; // VRV system outdoor unit condensing temperature, lower bound [C] - Real64 OUCondTempHigh; // VRV system outdoor unit condensing temperature, higher bound [C] - Real64 OUAirFlowRate; // Max condenser air flow rate [m3/s] - Real64 OUAirFlowRatePerCapcity; // Max condenser air flow rate per Evaporative Capacity [m3/s] - Real64 OUCondHeatRate; // Outdoor Unit Condenser Heat Release Rate, excluding piping loss [W] - Real64 OUEvapHeatRate; // Outdoor Unit Evaporator Heat Extract Rate, excluding piping loss [W] - Real64 OUFanPower; // Outdoor unit fan power at real conditions[W] - std::string refrigName; // Name of refrigerant, must match name in FluidName (see fluidpropertiesrefdata.idf) + int AlgorithmIUCtrl; // VRF indoor unit contrl algorithm, 1-High sensible, 2-Te/Tc constant + Array1D CompressorSpeed; // compressor speed array [rps] + Real64 CondensingTemp; // VRV system outdoor unit condensing temperature [C] + Real64 CondTempFixed; // Inddor unit condensing temperature, fixed, for AlgorithmIUCtrl is 2-Te/Tc constant [C] + Real64 CoffEvapCap; // Evaporative Capacity Correction Factor + Real64 CompActSpeed; // Compressor speed [rps] + Real64 CompMaxDeltaP; // maximum compressor pressure rise [Pa] + Real64 C1Te; // VRF Outdoor Unit Coefficient 1 to calculate Te,req [--] + Real64 C2Te; // VRF Outdoor Unit Coefficient 2 to calculate Te,req [--] + Real64 C3Te; // VRF Outdoor Unit Coefficient 3 to calculate Te,req [--] + Real64 C1Tc; // VRF Outdoor Unit Coefficient 1 to calculate Tc,req [--] + Real64 C2Tc; // VRF Outdoor Unit Coefficient 2 to calculate Tc,req [--] + Real64 C3Tc; // VRF Outdoor Unit Coefficient 3 to calculate Tc,req [--] + Real64 DiffOUTeTo; // Difference between Outdoor Unit Te and OAT during Simultaneous Heating and Cooling operations + Real64 EffCompInverter; // Compressor Inverter Efficiency + Real64 EvaporatingTemp; // VRV system outdoor unit evaporating temperature [C] + Real64 EvapTempFixed; // Indoor unit evaporating temperature, fixed, for AlgorithmIUCtrl is 2-Te/Tc constant [C] + Real64 HROUHexRatio; // HR OU Heat Exchanger Capacity Ratio [--] + Real64 IUEvaporatingTemp; // VRV system indoor unit evaporating temperature, min among all indoor units [C] + Real64 IUCondensingTemp; // VRV system indoor unit condensing temperature, max among all indoor units [C] + Real64 IUEvapTempLow; // VRV system indoor unit evaporating temperature, lower bound[C] + Real64 IUEvapTempHigh; // VRV system indoor unit evaporating temperature, higher bound [C] + Real64 IUCondTempLow; // VRV system indoor unit condensing temperature, lower bound [C] + Real64 IUCondTempHigh; // VRV system indoor unit condensing temperature, higher bound [C] + Real64 IUCondHeatRate; // Indoor Unit Condensers Total Heat Release Rate, excluding piping loss [W] + Real64 IUEvapHeatRate; // Outdoor Unit Evaporators Total Heat Extract Rate, excluding piping loss [W] + Real64 Ncomp; // compressor electric power [W] + Real64 NcompCooling; // compressor electric power at cooling mode [W] + Real64 NcompHeating; // compressor electric power at heating mode [W] + Array1D_int OUCoolingCAPFT; // index to outdoor unit cooling capacity function of temperature at different compressor speed + Array1D_int OUCoolingPWRFT; // index to outdoor unit cooling power function of temperature at different compressor speed + Real64 OUEvapTempLow; // VRV system outdoor unit evaporating temperature, lower bound[C] + Real64 OUEvapTempHigh; // VRV system outdoor unit evaporating temperature, higher bound [C] + Real64 OUCondTempLow; // VRV system outdoor unit condensing temperature, lower bound [C] + Real64 OUCondTempHigh; // VRV system outdoor unit condensing temperature, higher bound [C] + Real64 OUAirFlowRate; // Max condenser air flow rate [m3/s] + Real64 OUAirFlowRatePerCapcity; // Max condenser air flow rate per Evaporative Capacity [m3/s] + Real64 OUCondHeatRate; // Outdoor Unit Condenser Heat Release Rate, excluding piping loss [W] + Real64 OUEvapHeatRate; // Outdoor Unit Evaporator Heat Extract Rate, excluding piping loss [W] + Real64 OUFanPower; // Outdoor unit fan power at real conditions[W] + std::string refrigName; // Name of refrigerant, must match name in FluidName (see fluidpropertiesrefdata.idf) FluidProperties::RefrigProps *refrig; Real64 RatedEvapCapacity; // Rated Evaporative Capacity [W] Real64 RatedHeatCapacity; // Rated Heating Capacity [W] diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index 1715d43cb75..8a2ed876011 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -1283,13 +1283,13 @@ namespace OutdoorAirUnit { if (thisOutAirUnit.OAEquip(compLoop).Type == CompType::SteamCoil_AirHeat) { thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow = GetCoilMaxSteamFlowRate(state, thisOutAirUnit.OAEquip(compLoop).ComponentIndex, errFlag); - Real64 const rho = - FluidProperties::GetSatDensityRefrig(state, - state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidName, - Constant::SteamInitConvTemp, - 1.0, - state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidIndex, - RoutineName); + Real64 const rho = FluidProperties::GetSatDensityRefrig( + state, + state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidName, + Constant::SteamInitConvTemp, + 1.0, + state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum).FluidIndex, + RoutineName); thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow; thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MinVolWaterFlow; InitComponentNodes(state, diff --git a/src/EnergyPlus/Plant/Loop.cc b/src/EnergyPlus/Plant/Loop.cc index b186a777718..cc894f9a7c9 100644 --- a/src/EnergyPlus/Plant/Loop.cc +++ b/src/EnergyPlus/Plant/Loop.cc @@ -133,7 +133,7 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) if (this->FluidType == DataLoopNode::NodeFluidType::Water) { - Cp = FluidProperties::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); + Cp = FluidProperties::GetSpecificHeatGlycol(state, this->FluidName, TargetTemp, this->FluidIndex, RoutineName); switch (this->LoopDemandCalcScheme) { case DataPlant::LoopDemandCalcScheme::SingleSetPoint: { @@ -188,8 +188,10 @@ void PlantLoopData::CalcUnmetPlantDemand(EnergyPlusData &state) // Calculate the delta temperature DeltaTemp = LoopSetPointTemperature - TargetTemp; - EnthalpySteamSatVapor = FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); - EnthalpySteamSatLiquid = FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatVapor = + FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 1.0, this->FluidIndex, RoutineNameAlt); + EnthalpySteamSatLiquid = + FluidProperties::GetSatEnthalpyRefrig(state, this->FluidName, LoopSetPointTemperature, 0.0, this->FluidIndex, RoutineNameAlt); LatentHeatSteam = EnthalpySteamSatVapor - EnthalpySteamSatLiquid; diff --git a/src/EnergyPlus/Plant/LoopSide.cc b/src/EnergyPlus/Plant/LoopSide.cc index 7d91b9c4a7f..150d6cea60d 100644 --- a/src/EnergyPlus/Plant/LoopSide.cc +++ b/src/EnergyPlus/Plant/LoopSide.cc @@ -1999,10 +1999,10 @@ namespace DataPlant { Real64 const OutletTemp(state.dataLoopNodes->Node(OutletNode).Temp); Real64 const AverageTemp((InletTemp + OutletTemp) / 2.0); Real64 const ComponentCp(FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, - AverageTemp, - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, - RoutineName)); + state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, + AverageTemp, + state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidIndex, + RoutineName)); // Calculate the load altered by this component Real64 const LoadAlteration(ComponentMassFlowRate * ComponentCp * (OutletTemp - InletTemp)); diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index ced52fc434f..89c4fc4e631 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -393,7 +393,7 @@ void GetPlantLoopData(EnergyPlusData &state) ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", missing fluid data for Plant loop."); ErrorsFound = true; } else { - this_loop.FluidIndex = FluidProperties::GetGlycolNum(state, Alpha(3)); + this_loop.FluidIndex = FluidProperties::GetGlycolNum(state, Alpha(3)); if (this_loop.FluidIndex == 0) { ShowSevereError(state, CurrentModuleObject + "=\"" + Alpha(1) + "\", invalid glycol fluid data for Plant loop."); ErrorsFound = true; @@ -2633,19 +2633,19 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) if (state.dataPlnt->PlantLoop(LoopNum).FluidType != DataLoopNode::NodeFluidType::Steam) { Cp = FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(LoopNum).FluidName, - LoopSetPointTemp, - state.dataPlnt->PlantLoop(LoopNum).FluidIndex, - RoutineNameAlt); + state.dataPlnt->PlantLoop(LoopNum).FluidName, + LoopSetPointTemp, + state.dataPlnt->PlantLoop(LoopNum).FluidIndex, + RoutineNameAlt); StartEnthalpy = Cp * LoopSetPointTemp; } // Use Min/Max flow rates to initialize loop if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { rho = FluidProperties::GetDensityGlycol(state, - state.dataPlnt->PlantLoop(LoopNum).FluidName, - LoopSetPointTemp, - state.dataPlnt->PlantLoop(LoopNum).FluidIndex, - RoutineNameAlt); + state.dataPlnt->PlantLoop(LoopNum).FluidName, + LoopSetPointTemp, + state.dataPlnt->PlantLoop(LoopNum).FluidIndex, + RoutineNameAlt); LoopMaxMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MaxVolFlowRate * rho; LoopMinMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MinVolFlowRate * rho; @@ -2653,8 +2653,8 @@ void ReInitPlantLoopsAtFirstHVACIteration(EnergyPlusData &state) // use saturated liquid of steam at the loop setpoint temp as the starting enthalpy for a water loop if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { SteamTemp = 100.0; - SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + SteamDensity = FluidProperties::GetSatDensityRefrig( + state, fluidNameSteam, SteamTemp, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); LoopMaxMassFlowRate = state.dataPlnt->PlantLoop(LoopNum).MaxVolFlowRate * SteamDensity; StartEnthalpy = FluidProperties::GetSatEnthalpyRefrig( state, fluidNameSteam, LoopSetPointTemp, 0.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); @@ -3381,10 +3381,10 @@ void SizePlantLoop(EnergyPlusData &state, state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); if (PlantSizNum > 0 && allocated(state.dataSize->PlantSizData)) { // method only works if sizing delta T is avaiable Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, - state.dataPlnt->PlantLoop(LoopNum).FluidName, - Constant::InitConvTemp, - state.dataPlnt->PlantLoop(LoopNum).FluidIndex, - RoutineName); + state.dataPlnt->PlantLoop(LoopNum).FluidName, + Constant::InitConvTemp, + state.dataPlnt->PlantLoop(LoopNum).FluidIndex, + RoutineName); Real64 DesignPlantCapacity = cp * FluidDensity * state.dataSize->PlantSizData(PlantSizNum).DesVolFlowRate * state.dataSize->PlantSizData(PlantSizNum).DeltaT; state.dataSize->PlantSizData(PlantSizNum).DesCapacity = DesignPlantCapacity; // store it for later use in scaling @@ -3393,7 +3393,8 @@ void SizePlantLoop(EnergyPlusData &state, } } } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } @@ -3527,7 +3528,8 @@ void ResizePlantLoopLevelSizes(EnergyPlusData &state, int const LoopNum // Suppl FluidDensity = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Steam) { - FluidDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); + FluidDensity = + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, 100.0, 1.0, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); } else { assert(false); } diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index b293743f045..07523f92033 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -724,10 +724,10 @@ void InitPIU(EnergyPlusData &state, // plant upgrade note? why no separate handling of steam coil? add it ? // local plant fluid density Real64 const rho = FluidProperties::GetDensityGlycol(state, - state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidName, - Constant::HWInitConvTemp, - state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidIndex, - RoutineName); + state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidName, + Constant::HWInitConvTemp, + state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).FluidIndex, + RoutineName); thisPIU.MaxHotWaterFlow = rho * thisPIU.MaxVolHotWaterFlow; thisPIU.MinHotWaterFlow = rho * thisPIU.MinVolHotWaterFlow; @@ -1308,12 +1308,12 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) DesCoilLoad = PsyCpAirFnW(CoilOutHumRat) * DesMassFlow * (CoilOutTemp - CoilInTemp); Real64 constexpr TempSteamIn = 100.00; Real64 const EnthSteamInDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, thisPIU.HCoil_FluidIndex, RoutineName); Real64 const LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; Real64 const SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, thisPIU.HCoil_FluidIndex, RoutineName); int DummyWaterIndex = 1; Real64 const Cp = GetSpecificHeatGlycol( state, fluidNameWater, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, DummyWaterIndex, RoutineName); diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 594d1ecdd44..f00564541db 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -2566,10 +2566,10 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI if (this->HWplantLoc.loopNum > 0 && this->ReheatComp_Num != HeatingCoilType::SteamAirHeating) { // protect early calls before plant is setup rho = FluidProperties::GetDensityGlycol(state, - state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, - Constant::HWInitConvTemp, - state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, - RoutineName); + state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidName, + Constant::HWInitConvTemp, + state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).FluidIndex, + RoutineName); } else { rho = 1000.0; } @@ -3638,10 +3638,13 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS); if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) { TempSteamIn = 100.00; - EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); - EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); + EnthSteamInDry = + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + EnthSteamOutWet = + FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, this->FluidIndex, RoutineNameFull); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); + SteamDensity = + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, this->FluidIndex, RoutineNameFull); Cp = GetSpecificHeatGlycol(state, fluidNameWater, diff --git a/src/EnergyPlus/SteamCoils.cc b/src/EnergyPlus/SteamCoils.cc index 0067af18d0a..7362e912db3 100644 --- a/src/EnergyPlus/SteamCoils.cc +++ b/src/EnergyPlus/SteamCoils.cc @@ -1115,10 +1115,10 @@ namespace SteamCoils { // Steam heat exchangers would not have effectivness, since all of the steam is // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. - EnthSteamInDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); - EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; @@ -1186,9 +1186,9 @@ namespace SteamCoils { TempLoopOutToPump = TempWaterAtmPress - state.dataSteamCoils->SteamCoil(CoilNum).LoopSubcoolReturn; // Actual Steam Coil Outlet Enthalpy - EnthCoilOutlet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - - CpWater * SubcoolDeltaTemp; + EnthCoilOutlet = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName) - + CpWater * SubcoolDeltaTemp; // Enthalpy at Point 4 EnthAtAtmPress = FluidProperties::GetSatEnthalpyRefrig( @@ -1230,10 +1230,10 @@ namespace SteamCoils { // Steam heat exchangers would not have effectivness, since all of the steam is // converted to water and only then the steam trap allows it to leave the heat // exchanger, subsequently heat exchange is latent heat + subcooling. - EnthSteamInDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); - EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 0.0, state.dataSteamCoils->SteamCoil(CoilNum).FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; // CpWater = GetSpecificHeatGlycol('WATER', & diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc index 8631437f9dc..6b3632bba03 100644 --- a/src/EnergyPlus/UnitHeater.cc +++ b/src/EnergyPlus/UnitHeater.cc @@ -1268,13 +1268,13 @@ namespace UnitHeater { } if (DesCoilLoad >= SmallLoad) { TempSteamIn = 100.00; - EnthSteamInDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); - EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 0.0, state.dataUnitHeaters->RefrigIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); + SteamDensity = FluidProperties::GetSatDensityRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, state.dataUnitHeaters->RefrigIndex, RoutineName); MaxVolHotSteamFlowDes = DesCoilLoad / (SteamDensity * (LatentHeatSteam + state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * CPHW(state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp))); diff --git a/src/EnergyPlus/UtilityRoutines.cc b/src/EnergyPlus/UtilityRoutines.cc index e81815be352..e8c9af463f7 100644 --- a/src/EnergyPlus/UtilityRoutines.cc +++ b/src/EnergyPlus/UtilityRoutines.cc @@ -1234,8 +1234,8 @@ void ShowRecurringSevereErrorAtEnd(EnergyPlusData &state, void ShowRecurringSevereErrorAtEnd(EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation int &MsgIndex, // Recurring message index, if zero, next available index is assigned - Real64 const val, - std::string const &units // optional char string (<=15 length) of units for sum value + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value ) { @@ -1339,8 +1339,8 @@ void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation int &MsgIndex, // Recurring message index, if zero, next available index is assigned - Real64 const val, - std::string const &units // optional char string (<=15 length) of units for sum value + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value ) { @@ -1385,7 +1385,7 @@ void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, ++state.dataErrTracking->TotalWarningErrors; StoreRecurringErrorMessage(state, " ** Warning ** " + Message, MsgIndex, val, val, _, units, units, ""); } - + void ShowRecurringContinueErrorAtEnd(EnergyPlusData &state, std::string const &Message, // Message automatically written to "error file" at end of simulation int &MsgIndex, // Recurring message index, if zero, next available index is assigned diff --git a/src/EnergyPlus/UtilityRoutines.hh b/src/EnergyPlus/UtilityRoutines.hh index 9671a9f6e86..b8b360bc323 100644 --- a/src/EnergyPlus/UtilityRoutines.hh +++ b/src/EnergyPlus/UtilityRoutines.hh @@ -163,13 +163,11 @@ void ShowWarningMessage(EnergyPlusData &state, OptionalOutputFileRef OutUnit1 = {}, OptionalOutputFileRef OutUnit2 = {}); -void ShowRecurringSevereErrorAtEnd( - EnergyPlusData &state, - std::string const &Message, // Message automatically written to "error file" at end of simulation - int &MsgIndex, // Recurring message index, if zero, next available index is assigned - Real64 const val, // Track and report the max of the values passed to this argument - std::string const &units -); +void ShowRecurringSevereErrorAtEnd(EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, // Track and report the max of the values passed to this argument + std::string const &units); void ShowRecurringSevereErrorAtEnd( EnergyPlusData &state, @@ -183,12 +181,11 @@ void ShowRecurringSevereErrorAtEnd( std::string const &ReportSumUnits = "" // optional char string (<=15 length) of units for sum value ); -void ShowRecurringWarningErrorAtEnd( - EnergyPlusData &state, - std::string const &Message, // Message automatically written to "error file" at end of simulation - int &MsgIndex, // Recurring message index, if zero, next available index is assigned - Real64 const val, - std::string const &units // optional char string (<=15 length) of units for sum value +void ShowRecurringWarningErrorAtEnd(EnergyPlusData &state, + std::string const &Message, // Message automatically written to "error file" at end of simulation + int &MsgIndex, // Recurring message index, if zero, next available index is assigned + Real64 const val, + std::string const &units // optional char string (<=15 length) of units for sum value ); void ShowRecurringWarningErrorAtEnd( @@ -241,7 +238,7 @@ struct ErrorCountIndex int index = 0; int count = 0; }; - + struct ErrorObjectHeader { std::string_view routineName; diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index 3b10ee75a21..2a8440e0733 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -1707,7 +1707,8 @@ namespace VentilatedSlab { if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) { TempSteamIn = 100.00; - SteamDensity = FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + SteamDensity = + FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); ventSlab.MaxHotSteamFlow = SteamDensity * ventSlab.MaxVolHotSteamFlow; ventSlab.MinHotSteamFlow = SteamDensity * ventSlab.MinVolHotSteamFlow; @@ -2344,13 +2345,13 @@ namespace VentilatedSlab { DesCoilLoad = sizerHeatingCapacity.size(state, TempSize, ErrorsFound); } TempSteamIn = 100.00; - EnthSteamInDry = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); - EnthSteamOutWet = - FluidProperties::GetSatEnthalpyRefrig(state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + EnthSteamInDry = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + EnthSteamOutWet = FluidProperties::GetSatEnthalpyRefrig( + state, fluidNameSteam, TempSteamIn, 0.0, ventSlab.heatingCoil_FluidIndex, RoutineName); LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet; - SteamDensity = - FluidProperties::GetSatDensityRefrig(state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); + SteamDensity = FluidProperties::GetSatDensityRefrig( + state, fluidNameSteam, TempSteamIn, 1.0, ventSlab.heatingCoil_FluidIndex, RoutineName); Cp = GetSpecificHeatGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); rho = GetDensityGlycol(state, fluidNameWater, Constant::HWInitConvTemp, DummyWaterIndex, RoutineName); MaxVolHotSteamFlowDes = diff --git a/src/EnergyPlus/WaterToAirHeatPump.cc b/src/EnergyPlus/WaterToAirHeatPump.cc index 32c55f30d84..ed06f4cd8ef 100644 --- a/src/EnergyPlus/WaterToAirHeatPump.cc +++ b/src/EnergyPlus/WaterToAirHeatPump.cc @@ -127,7 +127,7 @@ namespace WaterToAirHeatPump { int HPNum; // The WatertoAirHP that you are currently loading input into // Obtains and Allocates WatertoAirHP related parameters from input file - if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once GetWatertoAirHPInput(state); state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; @@ -1325,9 +1325,9 @@ namespace WaterToAirHeatPump { LoadSideAirInletEnth_Unit = PsyHFnTdbW(heatPump.InletAirDBTemp, heatPump.InletAirHumRat); SourceSideFluidName = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidName; SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; - SourceSideVolFlowRate = - heatPump.InletWaterMassFlowRate / - FluidProperties::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / + FluidProperties::GetDensityGlycol( + state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); StillSimulatingFlag = true; @@ -1554,11 +1554,11 @@ namespace WaterToAirHeatPump { // Determine the Enthalpy of the Superheated Fluid at Load Side Outlet/Compressor Inlet SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, - heatPump.Refrigerant, - CompressInletTemp, - LoadSidePressure, - state.dataWaterToAirHeatPump->RefrigIndex, - RoutineNameCompressInletTemp); + heatPump.Refrigerant, + CompressInletTemp, + LoadSidePressure, + state.dataWaterToAirHeatPump->RefrigIndex, + RoutineNameCompressInletTemp); // Determining the suction state of the fluid from inlet state involves interation // Method employed... @@ -1577,7 +1577,8 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = + FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -1588,17 +1589,17 @@ namespace WaterToAirHeatPump { return; } CompSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, - heatPump.Refrigerant, - state.dataWaterToAirHeatPump->CompSuctionTemp, - SuctionPr, - state.dataWaterToAirHeatPump->RefrigIndex, - RoutineNameCompSuctionTemp); + heatPump.Refrigerant, + state.dataWaterToAirHeatPump->CompSuctionTemp, + SuctionPr, + state.dataWaterToAirHeatPump->RefrigIndex, + RoutineNameCompSuctionTemp); CompSuctionDensity = FluidProperties::GetSupHeatDensityRefrig(state, - heatPump.Refrigerant, - state.dataWaterToAirHeatPump->CompSuctionTemp, - SuctionPr, - state.dataWaterToAirHeatPump->RefrigIndex, - RoutineNameCompSuctionTemp); + heatPump.Refrigerant, + state.dataWaterToAirHeatPump->CompSuctionTemp, + SuctionPr, + state.dataWaterToAirHeatPump->RefrigIndex, + RoutineNameCompSuctionTemp); // Find Refrigerant Flow Rate switch (heatPump.compressorType) { @@ -1840,9 +1841,9 @@ namespace WaterToAirHeatPump { CpAir = PsyCpAirFnW(heatPump.InletAirHumRat); SourceSideFluidName = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidName; SourceSideFluidIndex = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidIndex; - SourceSideVolFlowRate = - heatPump.InletWaterMassFlowRate / - FluidProperties::GetDensityGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / + FluidProperties::GetDensityGlycol( + state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // If heat pump is not operating, return if (SensDemand == 0.0 || heatPump.InletAirMassFlowRate <= 0.0 || heatPump.InletWaterMassFlowRate <= 0.0) { @@ -1901,8 +1902,8 @@ namespace WaterToAirHeatPump { } // Determine Effectiveness of Source Side - CpFluid = - FluidProperties::GetSpecificHeatGlycol(state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); + CpFluid = FluidProperties::GetSpecificHeatGlycol( + state, SourceSideFluidName, heatPump.InletWaterTemp, SourceSideFluidIndex, RoutineNameSourceSideInletTemp); // IF (SourceSideFluidName=='WATER') THEN if (SourceSideFluidIndex == state.dataWaterToAirHeatPump->WaterIndex) { @@ -2001,11 +2002,11 @@ namespace WaterToAirHeatPump { // Determine the Enathalpy of the Superheated Fluid at Source Side Outlet/Compressor Inlet SuperHeatEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, - heatPump.Refrigerant, - CompressInletTemp, - SourceSidePressure, - state.dataWaterToAirHeatPump->RefrigIndex, - RoutineNameCompressInletTemp); + heatPump.Refrigerant, + CompressInletTemp, + SourceSidePressure, + state.dataWaterToAirHeatPump->RefrigIndex, + RoutineNameCompressInletTemp); // Determining the suction state of the fluid from inlet state involves interation // Method employed... @@ -2013,7 +2014,7 @@ namespace WaterToAirHeatPump { // check that with the inlet enthalpy ( as suction loss is isenthalpic). Iterate till desired accuracy is reached if (!Converged) { - CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( + CompSuctionSatTemp = FluidProperties::GetSatTemperatureRefrig( state, heatPump.Refrigerant, SuctionPr, state.dataWaterToAirHeatPump->RefrigIndex, RoutineNameSuctionPr); CompSuctionTemp1 = CompSuctionSatTemp; @@ -2048,7 +2049,8 @@ namespace WaterToAirHeatPump { static constexpr std::string_view RoutineName("CalcWaterToAirHPHeating:CalcCompSuctionTemp"); std::string Refrigerant; // Name of refrigerant int refrigIndex = state.dataWaterToAirHeatPump->RefrigIndex; - Real64 compSuctionEnth = FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); + Real64 compSuctionEnth = + FluidProperties::GetSupHeatEnthalpyRefrig(state, Refrigerant, CompSuctionTemp, SuctionPr, refrigIndex, RoutineName); return (compSuctionEnth - SuperHeatEnth) / SuperHeatEnth; }; @@ -2516,7 +2518,7 @@ namespace WaterToAirHeatPump { int WhichCoil; // Obtains and Allocates WatertoAirHP related parameters from input file - if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered state.dataWaterToAirHeatPump->WaterIndex = FluidProperties::GetGlycolNum(state, fluidNameWater); // Initialize the WaterIndex once GetWatertoAirHPInput(state); state.dataWaterToAirHeatPump->GetCoilsInputFlag = false; diff --git a/tst/EnergyPlus/unit/FluidProperties.unit.cc b/tst/EnergyPlus/unit/FluidProperties.unit.cc index 631475993fd..0c883e902da 100644 --- a/tst/EnergyPlus/unit/FluidProperties.unit.cc +++ b/tst/EnergyPlus/unit/FluidProperties.unit.cc @@ -142,12 +142,12 @@ TEST_F(EnergyPlusFixture, FluidProperties_InterpValuesForGlycolConc) // Test interpolation for the single-concentration scenario FluidProperties::InterpValuesForGlycolConc(*state, - NumCon, // number of concentrations (dimension of raw data) - NumTemp, // number of temperatures (dimension of raw data) - ConData, // concentrations for raw data - PropData, // raw property data (temperature,concentration) - ActCon, // concentration of actual fluid mix - Result); // interpolated output data at proper concentration + NumCon, // number of concentrations (dimension of raw data) + NumTemp, // number of temperatures (dimension of raw data) + ConData, // concentrations for raw data + PropData, // raw property data (temperature,concentration) + ActCon, // concentration of actual fluid mix + Result); // interpolated output data at proper concentration EXPECT_NEAR(1020.0, Result(1), 1e-6); EXPECT_NEAR(1010.0, Result(2), 1e-6); diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index f26b98a19f8..f26620cf1a4 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -5867,25 +5867,25 @@ TEST_F(EnergyPlusFixture, VRFTest_SysCurve_WaterCooled) EXPECT_NEAR(SysOutputProvided, state->dataZoneEnergyDemand->ZoneSysEnergyDemand(CurZoneNum).RemainingOutputReqToCoolSP, 1.0); rho = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, - state->dataSize->PlantSizData(1).ExitTemp, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, - RoutineName); + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, + state->dataSize->PlantSizData(1).ExitTemp, + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, + RoutineName); Cp = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, - state->dataSize->PlantSizData(1).ExitTemp, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, - RoutineName); + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, + state->dataSize->PlantSizData(1).ExitTemp, + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, + RoutineName); CondVolFlowRate = max(state->dataHVACVarRefFlow->VRF(VRFCond).CoolingCapacity, state->dataHVACVarRefFlow->VRF(VRFCond).HeatingCapacity) / (state->dataSize->PlantSizData(1).DeltaT * Cp * rho); EXPECT_DOUBLE_EQ(CondVolFlowRate, state->dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate); rho = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, - Constant::InitConvTemp, - state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, - RoutineName); + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidName, + Constant::InitConvTemp, + state->dataPlnt->PlantLoop(state->dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum).FluidIndex, + RoutineName); EXPECT_DOUBLE_EQ(state->dataHVACVarRefFlow->VRF(VRFCond).WaterCondenserDesignMassFlow, (state->dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate * rho)); diff --git a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc index 62898efe817..6bf1a8c30dd 100644 --- a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc +++ b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc @@ -1203,28 +1203,32 @@ TEST_F(LowTempRadiantSystemTest, AutosizeLowTempRadiantVariableFlowTest) CoolingCapacity = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad * state->dataLowTempRadSys->HydrRadSys(RadSysNum).ScaledCoolingCapacity; // hot water flow rate sizing calculation - Density = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, - 60.0, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, - "AutosizeLowTempRadiantVariableFlowTest"); - Cp = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, - 60.0, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, - "AutosizeLowTempRadiantVariableFlowTest"); + Density = + FluidProperties::GetDensityGlycol(*state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, + 60.0, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, + "AutosizeLowTempRadiantVariableFlowTest"); + Cp = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, + 60.0, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, + "AutosizeLowTempRadiantVariableFlowTest"); HotWaterFlowRate = HeatingCapacity / (state->dataSize->PlantSizData(1).DeltaT * Cp * Density); // chilled water flow rate sizing calculation - Density = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, - 5.05, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, - "AutosizeLowTempRadiantVariableFlowTest"); - Cp = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, - 5.05, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, - "AutosizeLowTempRadiantVariableFlowTest"); + Density = + FluidProperties::GetDensityGlycol(*state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, + 5.05, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, + "AutosizeLowTempRadiantVariableFlowTest"); + Cp = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, + 5.05, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, + "AutosizeLowTempRadiantVariableFlowTest"); ChilledWaterFlowRate = CoolingCapacity / (state->dataSize->PlantSizData(2).DeltaT * Cp * Density); // tuble length sizing calculation state->dataLowTempRadSys->HydrRadSys(RadSysNum).TotalSurfaceArea = @@ -2634,16 +2638,18 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad = 1000.0; // hot water volume flow rate sizing calculation - Density = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, - 60.0, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, - "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, - 60.0, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, - "LowTempRadConFlowSystemAutoSizeTempTest"); + Density = + FluidProperties::GetDensityGlycol(*state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, + 60.0, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, + "LowTempRadConFlowSystemAutoSizeTempTest"); + Cp = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidName, + 60.0, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum).FluidIndex, + "LowTempRadConFlowSystemAutoSizeTempTest"); Real64 HeatingLoad = state->dataSize->FinalZoneSizing(1).NonAirSysDesHeatLoad; Real64 DesHotWaterVolFlowRate = HeatingLoad / (state->dataSize->PlantSizData(1).DeltaT * Density * Cp); @@ -2659,16 +2665,18 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax = AutoSize; // chilled water volume flow rate sizing calculation - Density = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, - 5.05, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, - "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, - 5.05, - state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, - "LowTempRadConFlowSystemAutoSizeTempTest"); + Density = + FluidProperties::GetDensityGlycol(*state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, + 5.05, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, + "LowTempRadConFlowSystemAutoSizeTempTest"); + Cp = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidName, + 5.05, + state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum).FluidIndex, + "LowTempRadConFlowSystemAutoSizeTempTest"); Real64 CoolingLoad = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad; Real64 DesChilledWaterVolFlowRate = CoolingLoad / (state->dataSize->PlantSizData(2).DeltaT * Density * Cp); diff --git a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc index a6b596a5b76..597d8498c8f 100644 --- a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc +++ b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc @@ -692,8 +692,8 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) Real64 CoilDesWaterDeltaT = state->dataSize->PlantSizData(1).DeltaT; Real64 Cp = FluidProperties::GetSpecificHeatGlycol( *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); - Real64 rho = - FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); + Real64 rho = FluidProperties::GetDensityGlycol( + *state, state->dataPlnt->PlantLoop(1).FluidName, Constant::CWInitConvTemp, state->dataPlnt->PlantLoop(1).FluidIndex, " "); Real64 DesCoolingCoilWaterVolFlowRate = DesWaterCoolingCoilLoad / (CoilDesWaterDeltaT * Cp * rho); // check water coil water flow rate calc EXPECT_EQ(DesWaterCoolingCoilLoad, state->dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate); @@ -996,11 +996,14 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_SteamHeatingCoilAutoSizeTest) Real64 DesSteamCoilLoad = DesAirMassFlow * CpAirAvg * (DesCoilOutTemp - DesCoilInTemp); // do steam flow rate sizing calculation - Real64 EnthSteamIn = FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 EnthSteamOut = FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 SteamDensity = FluidProperties::GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); - Real64 CpOfCondensate = - FluidProperties::GetSatSpecificHeatRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamIn = + FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 EnthSteamOut = + FluidProperties::GetSatEnthalpyRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 SteamDensity = + FluidProperties::GetSatDensityRefrig(*state, "STEAM", Constant::SteamInitConvTemp, 1.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); + Real64 CpOfCondensate = FluidProperties::GetSatSpecificHeatRefrig( + *state, "STEAM", Constant::SteamInitConvTemp, 0.0, state->dataSteamCoils->SteamCoil(1).FluidIndex, ""); Real64 LatentHeatChange = EnthSteamIn - EnthSteamOut; Real64 DesMaxSteamVolFlowRate = DesSteamCoilLoad / (SteamDensity * (LatentHeatChange + state->dataSteamCoils->SteamCoil(1).DegOfSubcooling * CpOfCondensate)); diff --git a/tst/EnergyPlus/unit/UnitHeater.unit.cc b/tst/EnergyPlus/unit/UnitHeater.unit.cc index 8d673096237..b5472f8f702 100644 --- a/tst/EnergyPlus/unit/UnitHeater.unit.cc +++ b/tst/EnergyPlus/unit/UnitHeater.unit.cc @@ -1151,16 +1151,18 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest) EXPECT_FALSE(ErrorsFound); HWMaxVolFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; - HWDensity = FluidProperties::GetDensityGlycol(*state, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, - Constant::HWInitConvTemp, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, - "xxx"); - CpHW = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, - Constant::HWInitConvTemp, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, - "xxx"); + HWDensity = + FluidProperties::GetDensityGlycol(*state, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, + Constant::HWInitConvTemp, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, + "xxx"); + CpHW = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, + Constant::HWInitConvTemp, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, + "xxx"); HWPlantDeltaTDesign = state->dataSize->PlantSizData(PltSizHeatNum).DeltaT; // calculate hot water coil design capacity HWCoilDesignCapacity = HWMaxVolFlowRate * HWDensity * CpHW * HWPlantDeltaTDesign; @@ -1398,11 +1400,12 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) EXPECT_NEAR(UHHeatingRate, state->dataUnitHeaters->UnitHeat(UnitHeatNum).HeatPower, ConvTol); // verify the heat rate delivered by the hot water heating coil HWMassFlowRate = state->dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; - CpHW = FluidProperties::GetSpecificHeatGlycol(*state, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, - 60.0, - state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, - "UnitTest"); + CpHW = FluidProperties::GetSpecificHeatGlycol( + *state, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidName, + 60.0, + state->dataPlnt->PlantLoop(state->dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum).FluidIndex, + "UnitTest"); HWCoilHeatingRate = HWMassFlowRate * CpHW * (state->dataLoopNodes->Node(WCWaterInletNode).Temp - state->dataLoopNodes->Node(WCWaterOutletNode).Temp); EXPECT_NEAR(HWCoilHeatingRate, state->dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, ConvTol); diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 7dade685a33..e11cbf8fe26 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -1422,8 +1422,10 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) Real64 DesWaterFlowRate(0.0); // now size heating coil hot water flow rate at 60.0C - Cp = FluidProperties::GetSpecificHeatGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); - rho = FluidProperties::GetDensityGlycol(*state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + Cp = FluidProperties::GetSpecificHeatGlycol( + *state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); + rho = FluidProperties::GetDensityGlycol( + *state, state->dataPlnt->PlantLoop(1).FluidName, 60.0, state->dataPlnt->PlantLoop(1).FluidIndex, "Unit Test"); DesWaterFlowRate = DesCoilHeatingLoad / (state->dataSize->PlantSizData(1).DeltaT * Cp * rho); // check heating coil design water flow rate calculated here and sizing results are identical diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc index 53008112825..9b46f887f3f 100644 --- a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc @@ -309,5 +309,5 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir) // clean up state->dataWaterToAirHeatPump->WatertoAirHP.deallocate(); - delete state->dataFluidProps->refrigs(1); + delete state->dataFluidProps->refrigs(1); } From 00ce96634789168d327336c8437bf0b4128ac40c Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Wed, 24 Jul 2024 10:35:08 -0500 Subject: [PATCH 114/115] Fix format issue with custom_check --- src/EnergyPlus/FluidProperties.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 963be054cfa..58716dcb385 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -1102,7 +1102,7 @@ namespace FluidProperties { cAlphaFields(2), Alphas(2), "", - format("Valid options are (\"Enthalpy\", \"Density\"). Fluid will not be available for simulation.")); + R"(Valid options are ("Enthalpy", "Density"). Fluid will not be available for simulation.)"); ErrorsFound = true; continue; } From 44cc05155e320751539f8ef8c63ded1ca37894f9 Mon Sep 17 00:00:00 2001 From: Edwin Lee Date: Wed, 24 Jul 2024 11:57:46 -0500 Subject: [PATCH 115/115] Clang format again? --- src/EnergyPlus/FluidProperties.cc | 58 +++++++++++++++++++------------ 1 file changed, 35 insertions(+), 23 deletions(-) diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc index 58716dcb385..a27751e06b6 100644 --- a/src/EnergyPlus/FluidProperties.cc +++ b/src/EnergyPlus/FluidProperties.cc @@ -271,29 +271,41 @@ namespace FluidProperties { }; // Propylene Glycol Data: Specific Heat in J/(kg-k) - static constexpr std::array, DefaultNumGlyConcs> DefaultPropGlyCpData = { - {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, - 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData - // in - // J/kg-K - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4042.0, 4050.0, 4058.0, 4067.0, 4075.0, 4083.0, 4091.0, 4099.0, 4107.0, 4115.0, - 4123.0, 4131.0, 4139.0, 4147.0, 4155.0, 4163.0, 4171.0, 4179.0, 4187.0, 4195.0, 4203.0, 4211.0, 4219.0, 4227.0, 4235.0, 4243.0}, // Conc=0.1 - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3918.0, 3929.0, 3940.0, 3951.0, 3962.0, 3973.0, 3983.0, 3994.0, 4005.0, 4016.0, 4027.0, - 4038.0, 4049.0, 4060.0, 4071.0, 4082.0, 4093.0, 4104.0, 4115.0, 4126.0, 4136.0, 4147.0, 4158.0, 4169.0, 4180.0, 4191.0, 4202.0}, // Conc=0.2 - {0.0, 0.0, 0.0, 0.0, 0.0, 3765.0, 3779.0, 3793.0, 3807.0, 3820.0, 3834.0, 3848.0, 3862.0, 3875.0, 3889.0, 3903.0, 3917.0, - 3930.0, 3944.0, 3958.0, 3972.0, 3985.0, 3999.0, 4013.0, 4027.0, 4040.0, 4054.0, 4068.0, 4082.0, 4095.0, 4109.0, 4123.0, 4137.0}, // Conc=0.3 - {0.0, 0.0, 0.0, 0.0, 3586.0, 3603.0, 3619.0, 3636.0, 3652.0, 3669.0, 3685.0, 3702.0, 3718.0, 3735.0, 3751.0, 3768.0, 3784.0, - 3801.0, 3817.0, 3834.0, 3850.0, 3867.0, 3883.0, 3900.0, 3916.0, 3933.0, 3949.0, 3966.0, 3982.0, 3999.0, 4015.0, 4032.0, 4049.0}, // Conc=0.4 - {0.0, 0.0, 3358.0, 3378.0, 3397.0, 3416.0, 3435.0, 3455.0, 3474.0, 3493.0, 3513.0, 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, - 3648.0, 3667.0, 3686.0, 3706.0, 3725.0, 3744.0, 3763.0, 3783.0, 3802.0, 3821.0, 3841.0, 3860.0, 3879.0, 3898.0, 3918.0, 3937.0}, // Conc=0.5 - {3096.0, 3118.0, 3140.0, 3162.0, 3184.0, 3206.0, 3228.0, 3250.0, 3272.0, 3295.0, 3317.0, 3339.0, 3361.0, 3383.0, 3405.0, 3427.0, 3449.0, - 3471.0, 3493.0, 3515.0, 3537.0, 3559.0, 3581.0, 3603.0, 3625.0, 3647.0, 3670.0, 3692.0, 3714.0, 3736.0, 3758.0, 3780.0, 3802.0}, // Conc=0.6 - {2843.0, 2868.0, 2893.0, 2918.0, 2943.0, 2968.0, 2993.0, 3018.0, 3042.0, 3067.0, 3092.0, 3117.0, 3142.0, 3167.0, 3192.0, 3217.0, 3242.0, - 3266.0, 3291.0, 3316.0, 3341.0, 3366.0, 3391.0, 3416.0, 3441.0, 3465.0, 3490.0, 3515.0, 3540.0, 3565.0, 3590.0, 3615.0, 3640.0}, // Conc=0.7 - {2572.0, 2600.0, 2627.0, 2655.0, 2683.0, 2710.0, 2738.0, 2766.0, 2793.0, 2821.0, 2849.0, 2876.0, 2904.0, 2931.0, 2959.0, 2987.0, 3014.0, - 3042.0, 3070.0, 3097.0, 3125.0, 3153.0, 3180.0, 3208.0, 3236.0, 3263.0, 3291.0, 3319.0, 3346.0, 3374.0, 3402.0, 3429.0, 3457.0}, // Conc=0.8 - {2264.0, 2295.0, 2326.0, 2356.0, 2387.0, 2417.0, 2448.0, 2478.0, 2509.0, 2539.0, 2570.0, 2600.0, 2631.0, 2661.0, 2692.0, 2723.0, 2753.0, - 2784.0, 2814.0, 2845.0, 2875.0, 2906.0, 2936.0, 2967.0, 2997.0, 3028.0, 3058.0, 3089.0, 3119.0, 3150.0, 3181.0, 3211.0, 3242.0}} // Conc=0.9 + static constexpr std::array, DefaultNumGlyConcs> + DefaultPropGlyCpData = + { + {{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4217.0, 4198.0, 4191.0, 4185.0, + 4181.0, 4179.0, 4180.0, 4180.0, 4180.0, 4180.0, 4181.0, 4183.0, 4185.0, 4188.0, 4192.0, + 4196.0, 4200.0, 4203.0, 4208.0, 4213.0, 4218.0, 4223.0, 4228.0, 4233.0, 4238.0, 4243.0}, // DefaultWaterCpData + // in + // J/kg-K + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4042.0, 4050.0, 4058.0, 4067.0, + 4075.0, 4083.0, 4091.0, 4099.0, 4107.0, 4115.0, 4123.0, 4131.0, 4139.0, 4147.0, 4155.0, + 4163.0, 4171.0, 4179.0, 4187.0, 4195.0, 4203.0, 4211.0, 4219.0, 4227.0, 4235.0, 4243.0}, // Conc=0.1 + {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3918.0, 3929.0, 3940.0, 3951.0, 3962.0, + 3973.0, 3983.0, 3994.0, 4005.0, 4016.0, 4027.0, 4038.0, 4049.0, 4060.0, 4071.0, 4082.0, + 4093.0, 4104.0, 4115.0, 4126.0, 4136.0, 4147.0, 4158.0, 4169.0, 4180.0, 4191.0, 4202.0}, // Conc=0.2 + {0.0, 0.0, 0.0, 0.0, 0.0, 3765.0, 3779.0, 3793.0, 3807.0, 3820.0, 3834.0, + 3848.0, 3862.0, 3875.0, 3889.0, 3903.0, 3917.0, 3930.0, 3944.0, 3958.0, 3972.0, 3985.0, + 3999.0, 4013.0, 4027.0, 4040.0, 4054.0, 4068.0, 4082.0, 4095.0, 4109.0, 4123.0, 4137.0}, // Conc=0.3 + {0.0, 0.0, 0.0, 0.0, 3586.0, 3603.0, 3619.0, 3636.0, 3652.0, 3669.0, 3685.0, + 3702.0, 3718.0, 3735.0, 3751.0, 3768.0, 3784.0, 3801.0, 3817.0, 3834.0, 3850.0, 3867.0, + 3883.0, 3900.0, 3916.0, 3933.0, 3949.0, 3966.0, 3982.0, 3999.0, 4015.0, 4032.0, 4049.0}, // Conc=0.4 + {0.0, 0.0, 3358.0, 3378.0, 3397.0, 3416.0, 3435.0, 3455.0, 3474.0, 3493.0, 3513.0, + 3532.0, 3551.0, 3570.0, 3590.0, 3609.0, 3628.0, 3648.0, 3667.0, 3686.0, 3706.0, 3725.0, + 3744.0, 3763.0, 3783.0, 3802.0, 3821.0, 3841.0, 3860.0, 3879.0, 3898.0, 3918.0, 3937.0}, // Conc=0.5 + {3096.0, 3118.0, 3140.0, 3162.0, 3184.0, 3206.0, 3228.0, 3250.0, 3272.0, 3295.0, 3317.0, + 3339.0, 3361.0, 3383.0, 3405.0, 3427.0, 3449.0, 3471.0, 3493.0, 3515.0, 3537.0, 3559.0, + 3581.0, 3603.0, 3625.0, 3647.0, 3670.0, 3692.0, 3714.0, 3736.0, 3758.0, 3780.0, 3802.0}, // Conc=0.6 + {2843.0, 2868.0, 2893.0, 2918.0, 2943.0, 2968.0, 2993.0, 3018.0, 3042.0, 3067.0, 3092.0, + 3117.0, 3142.0, 3167.0, 3192.0, 3217.0, 3242.0, 3266.0, 3291.0, 3316.0, 3341.0, 3366.0, + 3391.0, 3416.0, 3441.0, 3465.0, 3490.0, 3515.0, 3540.0, 3565.0, 3590.0, 3615.0, 3640.0}, // Conc=0.7 + {2572.0, 2600.0, 2627.0, 2655.0, 2683.0, 2710.0, 2738.0, 2766.0, 2793.0, 2821.0, 2849.0, + 2876.0, 2904.0, 2931.0, 2959.0, 2987.0, 3014.0, 3042.0, 3070.0, 3097.0, 3125.0, 3153.0, + 3180.0, 3208.0, 3236.0, 3263.0, 3291.0, 3319.0, 3346.0, 3374.0, 3402.0, 3429.0, 3457.0}, // Conc=0.8 + {2264.0, 2295.0, 2326.0, 2356.0, 2387.0, 2417.0, 2448.0, 2478.0, 2509.0, 2539.0, 2570.0, + 2600.0, 2631.0, 2661.0, 2692.0, 2723.0, 2753.0, 2784.0, 2814.0, 2845.0, 2875.0, 2906.0, + 2936.0, 2967.0, 2997.0, 3028.0, 3058.0, 3089.0, 3119.0, 3150.0, 3181.0, 3211.0, 3242.0}} // Conc=0.9 }; // Propylene Glycol Data: Viscosity in mPa-s