Merge pull request #11508 from NatLabRockies/no-array-input

Refactor array-based input code to use key-based input (part 1)

Author: mitchute

src/EnergyPlus/Coils/CoilCoolingDX.cc

@@ -60,7 +60,6 @@
 #include <EnergyPlus/DataGlobals.hh>
 #include <EnergyPlus/DataHVACGlobals.hh>
 #include <EnergyPlus/DataHeatBalance.hh>
-#include <EnergyPlus/DataIPShortCuts.hh>
 #include <EnergyPlus/DataLoopNode.hh>
 #include <EnergyPlus/DataWater.hh>
 #include <EnergyPlus/Fans.hh>
@@ -116,35 +115,31 @@ int CoilCoolingDX::factory(EnergyPlus::EnergyPlusData &state, std::string const
 
 void CoilCoolingDX::getInput(EnergyPlusData &state)
 {
-    int numCoolingCoilDXs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataCoilCoolingDX->coilCoolingDXObjectName);
-    if (numCoolingCoilDXs <= 0) {
+    auto *inputProcessor = state.dataInputProcessing->inputProcessor.get();
+    auto const coilInstances = inputProcessor->epJSON.find(state.dataCoilCoolingDX->coilCoolingDXObjectName);
+    if (coilInstances == inputProcessor->epJSON.end() || coilInstances->empty()) {
         ShowFatalError(state, R"(No "Coil:Cooling:DX" objects in input file)");
     }
-    for (int coilNum = 1; coilNum <= numCoolingCoilDXs; ++coilNum) {
-        int NumAlphas;  // Number of Alphas for each GetObjectItem call
-        int NumNumbers; // Number of Numbers for each GetObjectItem call
-        int IOStatus;
-        state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataCoilCoolingDX->coilCoolingDXObjectName,
-                                                                 coilNum,
-                                                                 state.dataIPShortCut->cAlphaArgs,
-                                                                 NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
-                                                                 NumNumbers,
-                                                                 IOStatus);
+    auto const &coilSchemaProps = inputProcessor->getObjectSchemaProps(state, state.dataCoilCoolingDX->coilCoolingDXObjectName);
+
+    for (auto const &coilInstance : coilInstances.value().items()) {
+        auto const &coilFields = coilInstance.value();
         CoilCoolingDXInputSpecification input_specs;
-        input_specs.name = state.dataIPShortCut->cAlphaArgs(1);
-        input_specs.evaporator_inlet_node_name = state.dataIPShortCut->cAlphaArgs(2);
-        input_specs.evaporator_outlet_node_name = state.dataIPShortCut->cAlphaArgs(3);
-        input_specs.availability_schedule_name = state.dataIPShortCut->cAlphaArgs(4);
-        input_specs.condenser_zone_name = state.dataIPShortCut->cAlphaArgs(5);
-        input_specs.condenser_inlet_node_name = state.dataIPShortCut->cAlphaArgs(6);
-        input_specs.condenser_outlet_node_name = state.dataIPShortCut->cAlphaArgs(7);
-        input_specs.performance_object_name = state.dataIPShortCut->cAlphaArgs(8);
-        input_specs.condensate_collection_water_storage_tank_name = state.dataIPShortCut->cAlphaArgs(9);
-        input_specs.evaporative_condenser_supply_water_storage_tank_name = state.dataIPShortCut->cAlphaArgs(10);
+        input_specs.name = Util::makeUPPER(coilInstance.key());
+        input_specs.evaporator_inlet_node_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "evaporator_inlet_node_name");
+        input_specs.evaporator_outlet_node_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "evaporator_outlet_node_name");
+        input_specs.availability_schedule_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "availability_schedule_name");
+        input_specs.condenser_zone_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "condenser_zone_name");
+        input_specs.condenser_inlet_node_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "condenser_inlet_node_name");
+        input_specs.condenser_outlet_node_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "condenser_outlet_node_name");
+        input_specs.performance_object_name = inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "performance_object_name");
+        input_specs.condensate_collection_water_storage_tank_name =
+            inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "condensate_collection_water_storage_tank_name");
+        input_specs.evaporative_condenser_supply_water_storage_tank_name =
+            inputProcessor->getAlphaFieldValue(coilFields, coilSchemaProps, "evaporative_condenser_supply_water_storage_tank_name");
         CoilCoolingDX thisCoil;
         thisCoil.instantiateFromInputSpec(state, input_specs);
+        inputProcessor->markObjectAsUsed(state.dataCoilCoolingDX->coilCoolingDXObjectName, coilInstance.key());
         state.dataCoilCoolingDX->coilCoolingDXs.push_back(thisCoil);
     }
 }

src/EnergyPlus/Coils/CoilCoolingDXCurveFitOperatingMode.cc

@@ -53,7 +53,6 @@
 #include <EnergyPlus/Data/EnergyPlusData.hh>
 #include <EnergyPlus/DataEnvironment.hh>
 #include <EnergyPlus/DataHVACGlobals.hh>
-#include <EnergyPlus/DataIPShortCuts.hh>
 #include <EnergyPlus/DataSizing.hh>
 #include <EnergyPlus/EMSManager.hh>
 #include <EnergyPlus/InputProcessing/InputProcessor.hh>
@@ -125,50 +124,54 @@ void CoilCoolingDXCurveFitOperatingMode::instantiateFromInputSpec(EnergyPlus::En
 
 CoilCoolingDXCurveFitOperatingMode::CoilCoolingDXCurveFitOperatingMode(EnergyPlus::EnergyPlusData &state, const std::string &name_to_find)
 {
-    int numModes = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CoilCoolingDXCurveFitOperatingMode::object_name);
-    if (numModes <= 0) {
+    auto *inputProcessor = state.dataInputProcessing->inputProcessor.get();
+    auto const modeInstances = inputProcessor->epJSON.find(CoilCoolingDXCurveFitOperatingMode::object_name);
+    if (modeInstances == inputProcessor->epJSON.end()) {
         // error
     }
+    auto const &modeSchemaProps = inputProcessor->getObjectSchemaProps(state, CoilCoolingDXCurveFitOperatingMode::object_name);
     bool found_it = false;
-    for (int modeNum = 1; modeNum <= numModes; ++modeNum) {
-        int NumAlphas;  // Number of Alphas for each GetObjectItem call
-        int NumNumbers; // Number of Numbers for each GetObjectItem call
-        int IOStatus;
-        state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 CoilCoolingDXCurveFitOperatingMode::object_name,
-                                                                 modeNum,
-                                                                 state.dataIPShortCut->cAlphaArgs,
-                                                                 NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
-                                                                 NumNumbers,
-                                                                 IOStatus);
-        if (!Util::SameString(name_to_find, state.dataIPShortCut->cAlphaArgs(1))) {
+    for (auto const &modeInstance : modeInstances.value().items()) {
+        auto const modeName = Util::makeUPPER(modeInstance.key());
+        auto const &modeFields = modeInstance.value();
+        if (!Util::SameString(name_to_find, modeName)) {
             continue;
         }
         found_it = true;
 
         CoilCoolingDXCurveFitOperatingModeInputSpecification input_specs;
 
-        input_specs.name = state.dataIPShortCut->cAlphaArgs(1);
-        input_specs.gross_rated_total_cooling_capacity = state.dataIPShortCut->rNumericArgs(1);
-        input_specs.rated_evaporator_air_flow_rate = state.dataIPShortCut->rNumericArgs(2);
-        input_specs.rated_condenser_air_flow_rate = state.dataIPShortCut->rNumericArgs(3);
-        input_specs.maximum_cycling_rate = state.dataIPShortCut->rNumericArgs(4);
-        input_specs.ratio_of_initial_moisture_evaporation_rate_and_steady_state_latent_capacity = state.dataIPShortCut->rNumericArgs(5);
-        input_specs.latent_capacity_time_constant = state.dataIPShortCut->rNumericArgs(6);
-        input_specs.nominal_time_for_condensate_removal_to_begin = state.dataIPShortCut->rNumericArgs(7);
-        input_specs.apply_latent_degradation_to_speeds_greater_than_1 = state.dataIPShortCut->cAlphaArgs(2);
-        input_specs.condenser_type = state.dataIPShortCut->cAlphaArgs(3);
-        input_specs.nominal_evap_condenser_pump_power = state.dataIPShortCut->rNumericArgs(8);
-        input_specs.nominal_speed_number = state.dataIPShortCut->rNumericArgs(9);
-        for (int fieldNum = 4; fieldNum <= NumAlphas; fieldNum++) {
-            if (state.dataIPShortCut->cAlphaArgs(fieldNum).empty()) {
+        input_specs.name = modeName;
+        input_specs.gross_rated_total_cooling_capacity =
+            inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "rated_gross_total_cooling_capacity");
+        input_specs.rated_evaporator_air_flow_rate = inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "rated_evaporator_air_flow_rate");
+        input_specs.rated_condenser_air_flow_rate = inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "rated_condenser_air_flow_rate");
+        input_specs.maximum_cycling_rate = inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "maximum_cycling_rate");
+        input_specs.ratio_of_initial_moisture_evaporation_rate_and_steady_state_latent_capacity = inputProcessor->getRealFieldValue(
+            modeFields, modeSchemaProps, "ratio_of_initial_moisture_evaporation_rate_and_steady_state_latent_capacity");
+        input_specs.latent_capacity_time_constant = inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "latent_capacity_time_constant");
+        input_specs.nominal_time_for_condensate_removal_to_begin =
+            inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "nominal_time_for_condensate_removal_to_begin");
+        input_specs.apply_latent_degradation_to_speeds_greater_than_1 =
+            inputProcessor->getAlphaFieldValue(modeFields, modeSchemaProps, "apply_latent_degradation_to_speeds_greater_than_1");
+        input_specs.condenser_type = inputProcessor->getAlphaFieldValue(modeFields, modeSchemaProps, "condenser_type");
+        input_specs.nominal_evap_condenser_pump_power =
+            inputProcessor->getRealFieldValue(modeFields, modeSchemaProps, "nominal_evaporative_condenser_pump_power");
+        input_specs.nominal_speed_number = inputProcessor->getIntFieldValue(modeFields, modeSchemaProps, "nominal_speed_number");
+        for (int fieldNum = 1; fieldNum <= 10; ++fieldNum) {
+            auto const speedFieldName = format("speed_{}_name", fieldNum);
+            auto const speedName = inputProcessor->getAlphaFieldValue(modeFields, modeSchemaProps, speedFieldName);
+            if (speedName.empty()) {
                 break;
             }
-            input_specs.speed_data_names.push_back(state.dataIPShortCut->cAlphaArgs(fieldNum));
+            input_specs.speed_data_names.push_back(speedName);
+        }
+        if (input_specs.nominal_speed_number == 0) {
+            input_specs.nominal_speed_number = static_cast<int>(input_specs.speed_data_names.size());
         }
 
         this->instantiateFromInputSpec(state, input_specs);
+        inputProcessor->markObjectAsUsed(CoilCoolingDXCurveFitOperatingMode::object_name, modeInstance.key());
         break;
     }
 

src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc

@@ -51,7 +51,6 @@
 #include <EnergyPlus/DataEnvironment.hh>
 #include <EnergyPlus/DataGlobalConstants.hh>
 #include <EnergyPlus/DataHVACGlobals.hh>
-#include <EnergyPlus/DataIPShortCuts.hh>
 #include <EnergyPlus/Fans.hh>
 #include <EnergyPlus/General.hh>
 #include <EnergyPlus/GeneralRoutines.hh>
@@ -155,58 +154,51 @@ void CoilCoolingDXCurveFitPerformance::instantiateFromInputSpec(EnergyPlus::Ener
 CoilCoolingDXCurveFitPerformance::CoilCoolingDXCurveFitPerformance(EnergyPlus::EnergyPlusData &state, const std::string &name_to_find)
     : CoilCoolingDXPerformanceBase()
 {
-    int numPerformances = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CoilCoolingDXCurveFitPerformance::object_name);
-    if (numPerformances <= 0) {
+    std::string const objectName{CoilCoolingDXCurveFitPerformance::object_name};
+    auto *inputProcessor = state.dataInputProcessing->inputProcessor.get();
+    auto const performanceInstances = inputProcessor->epJSON.find(objectName);
+    if (performanceInstances == inputProcessor->epJSON.end()) {
         // error
     }
+    auto const &performanceSchemaProps = inputProcessor->getObjectSchemaProps(state, objectName);
     bool found_it = false;
-    for (int perfNum = 1; perfNum <= numPerformances; ++perfNum) {
-        int NumAlphas;  // Number of Alphas for each GetObjectItem call
-        int NumNumbers; // Number of Numbers for each GetObjectItem call
-        int IOStatus;
-        state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 CoilCoolingDXCurveFitPerformance::object_name,
-                                                                 perfNum,
-                                                                 state.dataIPShortCut->cAlphaArgs,
-                                                                 NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
-                                                                 NumNumbers,
-                                                                 IOStatus,
-                                                                 _,
-                                                                 state.dataIPShortCut->lAlphaFieldBlanks);
-        if (!Util::SameString(name_to_find, state.dataIPShortCut->cAlphaArgs(1))) {
+    for (auto const &performanceInstance : performanceInstances.value().items()) {
+        auto const performanceName = Util::makeUPPER(performanceInstance.key());
+        auto const &performanceFields = performanceInstance.value();
+        if (!Util::SameString(name_to_find, performanceName)) {
             continue;
         }
         found_it = true;
 
         CoilCoolingDXCurveFitPerformanceInputSpecification input_specs;
 
-        input_specs.name = state.dataIPShortCut->cAlphaArgs(1);
-        input_specs.crankcase_heater_capacity = state.dataIPShortCut->rNumericArgs(1);
-        input_specs.minimum_outdoor_dry_bulb_temperature_for_compressor_operation = state.dataIPShortCut->rNumericArgs(2);
-        input_specs.maximum_outdoor_dry_bulb_temperature_for_crankcase_heater_operation = state.dataIPShortCut->rNumericArgs(3);
-        if (state.dataIPShortCut->lNumericFieldBlanks(4)) {
-            input_specs.unit_internal_static_air_pressure = 0.0;
-        } else {
-            input_specs.unit_internal_static_air_pressure = state.dataIPShortCut->rNumericArgs(4);
-        }
-        if (!state.dataIPShortCut->lAlphaFieldBlanks(2)) {
-            input_specs.outdoor_temperature_dependent_crankcase_heater_capacity_curve_name = state.dataIPShortCut->cAlphaArgs(2);
-        }
-        input_specs.capacity_control = state.dataIPShortCut->cAlphaArgs(3);
-        input_specs.basin_heater_capacity = state.dataIPShortCut->rNumericArgs(5);
-        input_specs.basin_heater_setpoint_temperature = state.dataIPShortCut->rNumericArgs(6);
-        input_specs.basin_heater_operating_schedule_name = state.dataIPShortCut->cAlphaArgs(4);
-        input_specs.compressor_fuel_type = state.dataIPShortCut->cAlphaArgs(5);
-        input_specs.base_operating_mode_name = state.dataIPShortCut->cAlphaArgs(6);
-        if (!state.dataIPShortCut->lAlphaFieldBlanks(6)) {
-            input_specs.alternate_operating_mode_name = state.dataIPShortCut->cAlphaArgs(7);
-        }
-        if (!state.dataIPShortCut->lAlphaFieldBlanks(8)) {
-            input_specs.alternate_operating_mode2_name = state.dataIPShortCut->cAlphaArgs(8);
-        }
+        input_specs.name = performanceName;
+        input_specs.crankcase_heater_capacity =
+            inputProcessor->getRealFieldValue(performanceFields, performanceSchemaProps, "crankcase_heater_capacity");
+        input_specs.minimum_outdoor_dry_bulb_temperature_for_compressor_operation = inputProcessor->getRealFieldValue(
+            performanceFields, performanceSchemaProps, "minimum_outdoor_dry_bulb_temperature_for_compressor_operation");
+        input_specs.maximum_outdoor_dry_bulb_temperature_for_crankcase_heater_operation = inputProcessor->getRealFieldValue(
+            performanceFields, performanceSchemaProps, "maximum_outdoor_dry_bulb_temperature_for_crankcase_heater_operation");
+        input_specs.unit_internal_static_air_pressure =
+            inputProcessor->getRealFieldValue(performanceFields, performanceSchemaProps, "unit_internal_static_air_pressure");
+        input_specs.outdoor_temperature_dependent_crankcase_heater_capacity_curve_name = inputProcessor->getAlphaFieldValue(
+            performanceFields, performanceSchemaProps, "crankcase_heater_capacity_function_of_temperature_curve_name");
+        input_specs.capacity_control = inputProcessor->getAlphaFieldValue(performanceFields, performanceSchemaProps, "capacity_control_method");
+        input_specs.basin_heater_capacity =
+            inputProcessor->getRealFieldValue(performanceFields, performanceSchemaProps, "evaporative_condenser_basin_heater_capacity");
+        input_specs.basin_heater_setpoint_temperature =
+            inputProcessor->getRealFieldValue(performanceFields, performanceSchemaProps, "evaporative_condenser_basin_heater_setpoint_temperature");
+        input_specs.basin_heater_operating_schedule_name = inputProcessor->getAlphaFieldValue(
+            performanceFields, performanceSchemaProps, "evaporative_condenser_basin_heater_operating_schedule_name");
+        input_specs.compressor_fuel_type = inputProcessor->getAlphaFieldValue(performanceFields, performanceSchemaProps, "compressor_fuel_type");
+        input_specs.base_operating_mode_name = inputProcessor->getAlphaFieldValue(performanceFields, performanceSchemaProps, "base_operating_mode");
+        input_specs.alternate_operating_mode_name =
+            inputProcessor->getAlphaFieldValue(performanceFields, performanceSchemaProps, "alternative_operating_mode_1");
+        input_specs.alternate_operating_mode2_name =
+            inputProcessor->getAlphaFieldValue(performanceFields, performanceSchemaProps, "alternative_operating_mode_2");
 
         this->instantiateFromInputSpec(state, input_specs);
+        inputProcessor->markObjectAsUsed(objectName, performanceInstance.key());
         break;
     }