diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index 371ad5209e2..6f9a4bf7f84 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -78,10 +78,12 @@ #include #include #include +#include #include #include #include #include +#include #include #include #include @@ -127,10 +129,12 @@ namespace EnergyPlus { // after we've plumbed enough of the functions to allow OutputFiles outputFiles; + WaterUseData dataWaterUse; WindowACData dataWindowAC; WindowComplexManagerData dataWindowComplexManager; WindowEquivalentLayerData dataWindowEquivalentLayer; WindowManagerData dataWindowManager; + WindTurbineData dataWindTurbine; ZoneAirLoopEquipmentManagerData dataZoneAirLoopEquipmentManager; ZoneContaminantPredictorCorrectorData dataZoneContaminantPredictorCorrector; ZoneDehumidifierData dataZoneDehumidifier; @@ -172,10 +176,12 @@ namespace EnergyPlus { //outputReportTabular.clear_state(); pipes.clear_state(); dataPlantChillers.clear_state(); + dataWaterUse.clear_state(); dataWindowAC.clear_state(); dataWindowComplexManager.clear_state(); dataWindowEquivalentLayer.clear_state(); dataWindowManager.clear_state(); + dataWindTurbine.clear_state(); dataZoneAirLoopEquipmentManager.clear_state(); dataZoneContaminantPredictorCorrector.clear_state(); dataZoneDehumidifier.clear_state(); diff --git a/src/EnergyPlus/ElectricPowerServiceManager.cc b/src/EnergyPlus/ElectricPowerServiceManager.cc index 4aadbc0de43..d5437b1fc2d 100644 --- a/src/EnergyPlus/ElectricPowerServiceManager.cc +++ b/src/EnergyPlus/ElectricPowerServiceManager.cc @@ -55,6 +55,7 @@ // EnergyPlus Headers #include #include +#include #include #include #include @@ -66,7 +67,6 @@ #include #include #include -#include #include #include #include @@ -2207,8 +2207,8 @@ void GeneratorController::simGeneratorGetPowerOutput(EnergyPlusData &state, bool break; } case GeneratorType::windTurbine: { - WindTurbine::SimWindTurbine(DataGlobalConstants::iGeneratorWindTurbine, name, generatorIndex, runFlag, myElecLoadRequest); - WindTurbine::GetWTGeneratorResults( + WindTurbine::SimWindTurbine(state.dataWindTurbine, DataGlobalConstants::iGeneratorWindTurbine, name, generatorIndex, runFlag, myElecLoadRequest); + WindTurbine::GetWTGeneratorResults(state.dataWindTurbine, DataGlobalConstants::iGeneratorWindTurbine, generatorIndex, electProdRate, electricityProd, thermProdRate, thermalProd); electricPowerOutput = electProdRate; thermalPowerOutput = thermProdRate; diff --git a/src/EnergyPlus/InternalHeatGains.cc b/src/EnergyPlus/InternalHeatGains.cc index 740a3749ca6..14a7eb65273 100644 --- a/src/EnergyPlus/InternalHeatGains.cc +++ b/src/EnergyPlus/InternalHeatGains.cc @@ -5524,7 +5524,7 @@ namespace InternalHeatGains { CalcWaterThermalTankZoneGains(state); PipeHeatTransfer::PipeHTData::CalcZonePipesHeatGain(); - CalcWaterUseZoneGains(); + CalcWaterUseZoneGains(state.dataWaterUse); FigureFuelCellZoneGains(); FigureMicroCHPZoneGains(); initializeElectricPowerServiceZoneGains(); diff --git a/src/EnergyPlus/NonZoneEquipmentManager.cc b/src/EnergyPlus/NonZoneEquipmentManager.cc index b46f1cde2d2..da416fd40ff 100644 --- a/src/EnergyPlus/NonZoneEquipmentManager.cc +++ b/src/EnergyPlus/NonZoneEquipmentManager.cc @@ -122,7 +122,7 @@ namespace NonZoneEquipmentManager { CountNonZoneEquip = false; } - SimulateWaterUse(state.dataBranchInputManager, FirstHVACIteration); // simulate non-plant loop water use. + SimulateWaterUse(state.dataBranchInputManager, state.dataWaterUse, FirstHVACIteration); // simulate non-plant loop water use. if (!ZoneSizingCalc) { for (WaterHeaterNum = 1; WaterHeaterNum <= NumOfWaterHeater; ++WaterHeaterNum) { diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index 481420e1dfa..147c47419c4 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -974,7 +974,7 @@ namespace EnergyPlus { } else if (UtilityRoutines::SameString(this_comp_type, "WaterUse:Connections")) { this_comp.TypeOf_Num = TypeOf_WaterUseConnection; this_comp.CurOpSchemeType = DemandOpSchemeType; - this_comp.compPtr = WaterUse::WaterConnectionsType::factory(CompNames(CompNum)); + this_comp.compPtr = WaterUse::WaterConnectionsType::factory(state.dataWaterUse, CompNames(CompNum)); } else if (UtilityRoutines::SameString(this_comp_type, "Coil:Cooling:Water")) { this_comp.TypeOf_Num = TypeOf_CoilWaterCooling; this_comp.CurOpSchemeType = DemandOpSchemeType; diff --git a/src/EnergyPlus/StateManagement.cc b/src/EnergyPlus/StateManagement.cc index 82c19fe04d4..51b2c033bd1 100644 --- a/src/EnergyPlus/StateManagement.cc +++ b/src/EnergyPlus/StateManagement.cc @@ -216,7 +216,6 @@ #include #include #include -#include #include void EnergyPlus::clearThisState(EnergyPlusData &state) @@ -392,7 +391,6 @@ void EnergyPlus::clearAllStates(OutputFiles &outputFiles) WaterThermalTanks::clear_state(); WaterToAirHeatPumpSimple::clear_state(); EIRPlantLoopHeatPumps::EIRPlantLoopHeatPump::clear_state(); - WaterUse::clear_state(); WeatherManager::clear_state(); ResultsFramework::clear_state(); } diff --git a/src/EnergyPlus/WaterUse.cc b/src/EnergyPlus/WaterUse.cc index b637b291ba6..7db77c3cd3e 100644 --- a/src/EnergyPlus/WaterUse.cc +++ b/src/EnergyPlus/WaterUse.cc @@ -84,26 +84,7 @@ namespace WaterUse { // MODIFIED Brent Griffith, plant upgrade // RE-ENGINEERED na - bool getWaterUseInputFlag(true); - int numWaterEquipment(0); - int numWaterConnections(0); - - Array1D_bool CheckEquipName; - - Array1D WaterEquipment; - Array1D WaterConnections; - - void clear_state() - { - numWaterEquipment = 0; - numWaterConnections = 0; - getWaterUseInputFlag = true; - CheckEquipName.deallocate(); - WaterEquipment.deallocate(); - WaterConnections.deallocate(); - } - - void SimulateWaterUse(BranchInputManagerData &dataBranchInputManager, bool FirstHVACIteration) + void SimulateWaterUse(BranchInputManagerData &dataBranchInputManager, WaterUseData &dataWaterUse, bool FirstHVACIteration) { // SUBROUTINE INFORMATION: @@ -124,14 +105,14 @@ namespace WaterUse { int NumIteration; static bool MyEnvrnFlagLocal(true); - if (getWaterUseInputFlag) { - GetWaterUseInput(); - getWaterUseInputFlag = false; + if (dataWaterUse.getWaterUseInputFlag) { + GetWaterUseInput(dataWaterUse); + dataWaterUse.getWaterUseInputFlag = false; } if (DataGlobals::BeginEnvrnFlag && MyEnvrnFlagLocal) { - if (numWaterEquipment > 0) { - for (auto &e : WaterEquipment) { + if (dataWaterUse.numWaterEquipment > 0) { + for (auto &e : dataWaterUse.WaterEquipment) { e.SensibleRate = 0.0; e.SensibleEnergy = 0.0; e.LatentRate = 0.0; @@ -142,8 +123,8 @@ namespace WaterUse { } } - if (numWaterConnections > 0) { - for (auto &e : WaterConnections) + if (dataWaterUse.numWaterConnections > 0) { + for (auto &e : dataWaterUse.WaterConnections) e.TotalMassFlowRate = 0.0; } @@ -153,65 +134,65 @@ namespace WaterUse { if (!DataGlobals::BeginEnvrnFlag) MyEnvrnFlagLocal = true; // Simulate all unconnected WATER USE EQUIPMENT objects - for (WaterEquipNum = 1; WaterEquipNum <= numWaterEquipment; ++WaterEquipNum) { - if (WaterEquipment(WaterEquipNum).Connections == 0) { - WaterEquipment(WaterEquipNum).CalcEquipmentFlowRates(); - WaterEquipment(WaterEquipNum).CalcEquipmentDrainTemp(); + for (WaterEquipNum = 1; WaterEquipNum <= dataWaterUse.numWaterEquipment; ++WaterEquipNum) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).Connections == 0) { + dataWaterUse.WaterEquipment(WaterEquipNum).CalcEquipmentFlowRates(dataWaterUse); + dataWaterUse.WaterEquipment(WaterEquipNum).CalcEquipmentDrainTemp(); } } // WaterEquipNum - ReportStandAloneWaterUse(); + ReportStandAloneWaterUse(dataWaterUse); // Simulate WATER USE CONNECTIONS objects and connected WATER USE EQUIPMENT objects - for (WaterConnNum = 1; WaterConnNum <= numWaterConnections; ++WaterConnNum) { + for (WaterConnNum = 1; WaterConnNum <= dataWaterUse.numWaterConnections; ++WaterConnNum) { - if (!WaterConnections(WaterConnNum).StandAlone) continue; // only model non plant connections here + if (!dataWaterUse.WaterConnections(WaterConnNum).StandAlone) continue; // only model non plant connections here - WaterConnections(WaterConnNum).InitConnections(dataBranchInputManager); + dataWaterUse.WaterConnections(WaterConnNum).InitConnections(dataBranchInputManager, dataWaterUse); NumIteration = 0; while (true) { ++NumIteration; - WaterConnections(WaterConnNum).CalcConnectionsFlowRates(FirstHVACIteration); - WaterConnections(WaterConnNum).CalcConnectionsDrainTemp(); - WaterConnections(WaterConnNum).CalcConnectionsHeatRecovery(); + dataWaterUse.WaterConnections(WaterConnNum).CalcConnectionsFlowRates(dataWaterUse, FirstHVACIteration); + dataWaterUse.WaterConnections(WaterConnNum).CalcConnectionsDrainTemp(dataWaterUse); + dataWaterUse.WaterConnections(WaterConnNum).CalcConnectionsHeatRecovery(); - if (WaterConnections(WaterConnNum).TempError < Tolerance) { + if (dataWaterUse.WaterConnections(WaterConnNum).TempError < Tolerance) { break; } else if (NumIteration > MaxIterations) { if (!DataGlobals::WarmupFlag) { - if (WaterConnections(WaterConnNum).MaxIterationsErrorIndex == 0) { - ShowWarningError("WaterUse:Connections = " + WaterConnections(WaterConnNum).Name + + if (dataWaterUse.WaterConnections(WaterConnNum).MaxIterationsErrorIndex == 0) { + ShowWarningError("WaterUse:Connections = " + dataWaterUse.WaterConnections(WaterConnNum).Name + ": Heat recovery temperature did not converge"); ShowContinueErrorTimeStamp(""); } - ShowRecurringWarningErrorAtEnd("WaterUse:Connections = " + WaterConnections(WaterConnNum).Name + + ShowRecurringWarningErrorAtEnd("WaterUse:Connections = " + dataWaterUse.WaterConnections(WaterConnNum).Name + ": Heat recovery temperature did not converge", - WaterConnections(WaterConnNum).MaxIterationsErrorIndex); + dataWaterUse.WaterConnections(WaterConnNum).MaxIterationsErrorIndex); } break; } } // WHILE - WaterConnections(WaterConnNum).UpdateWaterConnections(); - WaterConnections(WaterConnNum).ReportWaterUse(); + dataWaterUse.WaterConnections(WaterConnNum).UpdateWaterConnections(); + dataWaterUse.WaterConnections(WaterConnNum).ReportWaterUse(dataWaterUse); } // WaterConnNum } - PlantComponent *WaterConnectionsType::factory(std::string const &objectName) + PlantComponent *WaterConnectionsType::factory(WaterUseData &dataWaterUse, std::string const &objectName) { // Process the input data - if (getWaterUseInputFlag) { - GetWaterUseInput(); - getWaterUseInputFlag = false; + if (dataWaterUse.getWaterUseInputFlag) { + GetWaterUseInput(dataWaterUse); + dataWaterUse.getWaterUseInputFlag = false; } // Now look for this particular object in the list - for (auto &thisWC : WaterConnections) { + for (auto &thisWC : dataWaterUse.WaterConnections) { if (thisWC.Name == objectName) { return &thisWC; } @@ -241,19 +222,19 @@ namespace WaterUse { Real64 const Tolerance(0.1); // Make input? if (DataGlobals::BeginEnvrnFlag && this->MyEnvrnFlag) { - if (numWaterEquipment > 0) { - for (int i = WaterEquipment.l(), e = WaterEquipment.u(); i <= e; ++i) { - WaterEquipment(i).reset(); + if (state.dataWaterUse.numWaterEquipment > 0) { + for (int i = state.dataWaterUse.WaterEquipment.l(), e = state.dataWaterUse.WaterEquipment.u(); i <= e; ++i) { + state.dataWaterUse.WaterEquipment(i).reset(); - if (WaterEquipment(i).setupMyOutputVars) { - WaterEquipment(i).setupOutputVars(); - WaterEquipment(i).setupMyOutputVars = false; + if (state.dataWaterUse.WaterEquipment(i).setupMyOutputVars) { + state.dataWaterUse.WaterEquipment(i).setupOutputVars(state.dataWaterUse); + state.dataWaterUse.WaterEquipment(i).setupMyOutputVars = false; } } } - if (numWaterConnections > 0) { - for (auto &e : WaterConnections) + if (state.dataWaterUse.numWaterConnections > 0) { + for (auto &e : state.dataWaterUse.WaterConnections) e.TotalMassFlowRate = 0.0; } @@ -262,15 +243,15 @@ namespace WaterUse { if (!DataGlobals::BeginEnvrnFlag) this->MyEnvrnFlag = true; - this->InitConnections(state.dataBranchInputManager); + this->InitConnections(state.dataBranchInputManager, state.dataWaterUse); int NumIteration = 0; while (true) { ++NumIteration; - this->CalcConnectionsFlowRates(FirstHVACIteration); - this->CalcConnectionsDrainTemp(); + this->CalcConnectionsFlowRates(state.dataWaterUse, FirstHVACIteration); + this->CalcConnectionsDrainTemp(state.dataWaterUse); this->CalcConnectionsHeatRecovery(); if (this->TempError < Tolerance) { @@ -289,10 +270,10 @@ namespace WaterUse { } // WHILE this->UpdateWaterConnections(); - this->ReportWaterUse(); + this->ReportWaterUse(state.dataWaterUse); } - void GetWaterUseInput() + void GetWaterUseInput(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -308,12 +289,12 @@ namespace WaterUse { int AlphaNum; DataIPShortCuts::cCurrentModuleObject = "WaterUse:Equipment"; - numWaterEquipment = inputProcessor->getNumObjectsFound(DataIPShortCuts::cCurrentModuleObject); + dataWaterUse.numWaterEquipment = inputProcessor->getNumObjectsFound(DataIPShortCuts::cCurrentModuleObject); - if (numWaterEquipment > 0) { - WaterEquipment.allocate(numWaterEquipment); + if (dataWaterUse.numWaterEquipment > 0) { + dataWaterUse.WaterEquipment.allocate(dataWaterUse.numWaterEquipment); - for (int WaterEquipNum = 1; WaterEquipNum <= numWaterEquipment; ++WaterEquipNum) { + for (int WaterEquipNum = 1; WaterEquipNum <= dataWaterUse.numWaterEquipment; ++WaterEquipNum) { inputProcessor->getObjectItem(DataIPShortCuts::cCurrentModuleObject, WaterEquipNum, DataIPShortCuts::cAlphaArgs, @@ -326,17 +307,17 @@ namespace WaterUse { DataIPShortCuts::cAlphaFieldNames, DataIPShortCuts::cNumericFieldNames); UtilityRoutines::IsNameEmpty(DataIPShortCuts::cAlphaArgs(1), DataIPShortCuts::cCurrentModuleObject, ErrorsFound); - WaterEquipment(WaterEquipNum).Name = DataIPShortCuts::cAlphaArgs(1); + dataWaterUse.WaterEquipment(WaterEquipNum).Name = DataIPShortCuts::cAlphaArgs(1); - WaterEquipment(WaterEquipNum).EndUseSubcatName = DataIPShortCuts::cAlphaArgs(2); + dataWaterUse.WaterEquipment(WaterEquipNum).EndUseSubcatName = DataIPShortCuts::cAlphaArgs(2); - WaterEquipment(WaterEquipNum).PeakVolFlowRate = DataIPShortCuts::rNumericArgs(1); + dataWaterUse.WaterEquipment(WaterEquipNum).PeakVolFlowRate = DataIPShortCuts::rNumericArgs(1); if ((NumAlphas > 2) && (!DataIPShortCuts::lAlphaFieldBlanks(3))) { - WaterEquipment(WaterEquipNum).FlowRateFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(3)); + dataWaterUse.WaterEquipment(WaterEquipNum).FlowRateFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(3)); // If no FlowRateFracSchedule, fraction defaults to 1.0 - if (WaterEquipment(WaterEquipNum).FlowRateFracSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).FlowRateFracSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(3) + '=' + DataIPShortCuts::cAlphaArgs(3)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -344,9 +325,9 @@ namespace WaterUse { } if ((NumAlphas > 3) && (!DataIPShortCuts::lAlphaFieldBlanks(4))) { - WaterEquipment(WaterEquipNum).TargetTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(4)); + dataWaterUse.WaterEquipment(WaterEquipNum).TargetTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(4)); - if (WaterEquipment(WaterEquipNum).TargetTempSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).TargetTempSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(4) + '=' + DataIPShortCuts::cAlphaArgs(4)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -354,11 +335,11 @@ namespace WaterUse { } if ((NumAlphas > 4) && (!DataIPShortCuts::lAlphaFieldBlanks(5))) { - WaterEquipment(WaterEquipNum).HotTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(5)); + dataWaterUse.WaterEquipment(WaterEquipNum).HotTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(5)); // If no HotTempSchedule, there is no hot water. // HotTempSchedule is ignored if connected to a plant loop via WATER USE CONNECTIONS - if (WaterEquipment(WaterEquipNum).HotTempSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).HotTempSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(5) + '=' + DataIPShortCuts::cAlphaArgs(5)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -366,10 +347,10 @@ namespace WaterUse { } if ((NumAlphas > 5) && (!DataIPShortCuts::lAlphaFieldBlanks(6))) { - WaterEquipment(WaterEquipNum).ColdTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(6)); + dataWaterUse.WaterEquipment(WaterEquipNum).ColdTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(6)); // If no ColdTempSchedule, temperatures will be calculated by WATER MAINS TEMPERATURES object - if (WaterEquipment(WaterEquipNum).ColdTempSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).ColdTempSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(6) + '=' + DataIPShortCuts::cAlphaArgs(6)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -377,9 +358,9 @@ namespace WaterUse { } if ((NumAlphas > 6) && (!DataIPShortCuts::lAlphaFieldBlanks(7))) { - WaterEquipment(WaterEquipNum).Zone = UtilityRoutines::FindItemInList(DataIPShortCuts::cAlphaArgs(7), DataHeatBalance::Zone); + dataWaterUse.WaterEquipment(WaterEquipNum).Zone = UtilityRoutines::FindItemInList(DataIPShortCuts::cAlphaArgs(7), DataHeatBalance::Zone); - if (WaterEquipment(WaterEquipNum).Zone == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).Zone == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(7) + '=' + DataIPShortCuts::cAlphaArgs(7)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -387,9 +368,9 @@ namespace WaterUse { } if ((NumAlphas > 7) && (!DataIPShortCuts::lAlphaFieldBlanks(8))) { - WaterEquipment(WaterEquipNum).SensibleFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(8)); + dataWaterUse.WaterEquipment(WaterEquipNum).SensibleFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(8)); - if (WaterEquipment(WaterEquipNum).SensibleFracSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).SensibleFracSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(8) + '=' + DataIPShortCuts::cAlphaArgs(8)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -397,9 +378,9 @@ namespace WaterUse { } if ((NumAlphas > 8) && (!DataIPShortCuts::lAlphaFieldBlanks(9))) { - WaterEquipment(WaterEquipNum).LatentFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(9)); + dataWaterUse.WaterEquipment(WaterEquipNum).LatentFracSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(9)); - if (WaterEquipment(WaterEquipNum).LatentFracSchedule == 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).LatentFracSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(9) + '=' + DataIPShortCuts::cAlphaArgs(9)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -412,12 +393,12 @@ namespace WaterUse { } DataIPShortCuts::cCurrentModuleObject = "WaterUse:Connections"; - numWaterConnections = inputProcessor->getNumObjectsFound(DataIPShortCuts::cCurrentModuleObject); + dataWaterUse.numWaterConnections = inputProcessor->getNumObjectsFound(DataIPShortCuts::cCurrentModuleObject); - if (numWaterConnections > 0) { - WaterConnections.allocate(numWaterConnections); + if (dataWaterUse.numWaterConnections > 0) { + dataWaterUse.WaterConnections.allocate(dataWaterUse.numWaterConnections); - for (int WaterConnNum = 1; WaterConnNum <= numWaterConnections; ++WaterConnNum) { + for (int WaterConnNum = 1; WaterConnNum <= dataWaterUse.numWaterConnections; ++WaterConnNum) { inputProcessor->getObjectItem(DataIPShortCuts::cCurrentModuleObject, WaterConnNum, DataIPShortCuts::cAlphaArgs, @@ -430,10 +411,10 @@ namespace WaterUse { DataIPShortCuts::cAlphaFieldNames, DataIPShortCuts::cNumericFieldNames); UtilityRoutines::IsNameEmpty(DataIPShortCuts::cAlphaArgs(1), DataIPShortCuts::cCurrentModuleObject, ErrorsFound); - WaterConnections(WaterConnNum).Name = DataIPShortCuts::cAlphaArgs(1); + dataWaterUse.WaterConnections(WaterConnNum).Name = DataIPShortCuts::cAlphaArgs(1); if ((!DataIPShortCuts::lAlphaFieldBlanks(2)) || (!DataIPShortCuts::lAlphaFieldBlanks(3))) { - WaterConnections(WaterConnNum).InletNode = NodeInputManager::GetOnlySingleNode(DataIPShortCuts::cAlphaArgs(2), + dataWaterUse.WaterConnections(WaterConnNum).InletNode = NodeInputManager::GetOnlySingleNode(DataIPShortCuts::cAlphaArgs(2), ErrorsFound, DataIPShortCuts::cCurrentModuleObject, DataIPShortCuts::cAlphaArgs(1), @@ -441,7 +422,7 @@ namespace WaterUse { DataLoopNode::NodeConnectionType_Inlet, 1, DataLoopNode::ObjectIsNotParent); - WaterConnections(WaterConnNum).OutletNode = NodeInputManager::GetOnlySingleNode(DataIPShortCuts::cAlphaArgs(3), + dataWaterUse.WaterConnections(WaterConnNum).OutletNode = NodeInputManager::GetOnlySingleNode(DataIPShortCuts::cAlphaArgs(3), ErrorsFound, DataIPShortCuts::cCurrentModuleObject, DataIPShortCuts::cAlphaArgs(1), @@ -458,33 +439,33 @@ namespace WaterUse { "DHW Nodes"); } else { // If no plant nodes are connected, simulate in stand-alone mode. - WaterConnections(WaterConnNum).StandAlone = true; + dataWaterUse.WaterConnections(WaterConnNum).StandAlone = true; } if (!DataIPShortCuts::lAlphaFieldBlanks(4)) { - WaterManager::SetupTankDemandComponent(WaterConnections(WaterConnNum).Name, + WaterManager::SetupTankDemandComponent(dataWaterUse.WaterConnections(WaterConnNum).Name, DataIPShortCuts::cCurrentModuleObject, DataIPShortCuts::cAlphaArgs(4), ErrorsFound, - WaterConnections(WaterConnNum).SupplyTankNum, - WaterConnections(WaterConnNum).TankDemandID); + dataWaterUse.WaterConnections(WaterConnNum).SupplyTankNum, + dataWaterUse.WaterConnections(WaterConnNum).TankDemandID); } if (!DataIPShortCuts::lAlphaFieldBlanks(5)) { - WaterManager::SetupTankSupplyComponent(WaterConnections(WaterConnNum).Name, + WaterManager::SetupTankSupplyComponent(dataWaterUse.WaterConnections(WaterConnNum).Name, DataIPShortCuts::cCurrentModuleObject, DataIPShortCuts::cAlphaArgs(5), ErrorsFound, - WaterConnections(WaterConnNum).RecoveryTankNum, - WaterConnections(WaterConnNum).TankSupplyID); + dataWaterUse.WaterConnections(WaterConnNum).RecoveryTankNum, + dataWaterUse.WaterConnections(WaterConnNum).TankSupplyID); } if (!DataIPShortCuts::lAlphaFieldBlanks(6)) { - WaterConnections(WaterConnNum).HotTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(6)); + dataWaterUse.WaterConnections(WaterConnNum).HotTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(6)); // If no HotTempSchedule, there is no hot water. // HotTempSchedule is ignored if connected to a plant loop via WATER USE CONNECTIONS - if (WaterConnections(WaterConnNum).HotTempSchedule == 0) { + if (dataWaterUse.WaterConnections(WaterConnNum).HotTempSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(6) + '=' + DataIPShortCuts::cAlphaArgs(6)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -492,10 +473,10 @@ namespace WaterUse { } if (!DataIPShortCuts::lAlphaFieldBlanks(7)) { - WaterConnections(WaterConnNum).ColdTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(7)); + dataWaterUse.WaterConnections(WaterConnNum).ColdTempSchedule = ScheduleManager::GetScheduleIndex(DataIPShortCuts::cAlphaArgs(7)); // If no ColdTempSchedule, temperatures will be calculated by WATER MAINS TEMPERATURES object - if (WaterConnections(WaterConnNum).ColdTempSchedule == 0) { + if (dataWaterUse.WaterConnections(WaterConnNum).ColdTempSchedule == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(7) + '=' + DataIPShortCuts::cAlphaArgs(7)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; @@ -503,16 +484,16 @@ namespace WaterUse { } if ((!DataIPShortCuts::lAlphaFieldBlanks(8)) && (DataIPShortCuts::cAlphaArgs(8) != "NONE")) { - WaterConnections(WaterConnNum).HeatRecovery = true; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecovery = true; { auto const SELECT_CASE_var(DataIPShortCuts::cAlphaArgs(8)); if (SELECT_CASE_var == "IDEAL") { - WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::Ideal; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::Ideal; } else if (SELECT_CASE_var == "COUNTERFLOW") { - WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::CounterFlow; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::CounterFlow; } else if (SELECT_CASE_var == "CROSSFLOW") { - WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::CrossFlow; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryHX = HeatRecoveryHXEnum::CrossFlow; } else { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(8) + '=' + DataIPShortCuts::cAlphaArgs(8)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); @@ -523,11 +504,11 @@ namespace WaterUse { { auto const SELECT_CASE_var(DataIPShortCuts::cAlphaArgs(9)); if (SELECT_CASE_var == "PLANT") { - WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::Plant; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::Plant; } else if (SELECT_CASE_var == "EQUIPMENT") { - WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::Equipment; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::Equipment; } else if (SELECT_CASE_var == "PLANTANDEQUIPMENT") { - WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::PlantAndEquip; + dataWaterUse.WaterConnections(WaterConnNum).HeatRecoveryConfig = HeatRecoveryConfigEnum::PlantAndEquip; } else { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(9) + '=' + DataIPShortCuts::cAlphaArgs(9)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); @@ -536,31 +517,31 @@ namespace WaterUse { } } - WaterConnections(WaterConnNum).HXUA = DataIPShortCuts::rNumericArgs(1); + dataWaterUse.WaterConnections(WaterConnNum).HXUA = DataIPShortCuts::rNumericArgs(1); - WaterConnections(WaterConnNum).myWaterEquipArr.allocate(NumAlphas - 9); + dataWaterUse.WaterConnections(WaterConnNum).myWaterEquipArr.allocate(NumAlphas - 9); for (AlphaNum = 10; AlphaNum <= NumAlphas; ++AlphaNum) { - int WaterEquipNum = UtilityRoutines::FindItemInList(DataIPShortCuts::cAlphaArgs(AlphaNum), WaterEquipment); + int WaterEquipNum = UtilityRoutines::FindItemInList(DataIPShortCuts::cAlphaArgs(AlphaNum), dataWaterUse.WaterEquipment); if (WaterEquipNum == 0) { ShowSevereError("Invalid " + DataIPShortCuts::cAlphaFieldNames(AlphaNum) + '=' + DataIPShortCuts::cAlphaArgs(AlphaNum)); ShowContinueError("Entered in " + DataIPShortCuts::cCurrentModuleObject + '=' + DataIPShortCuts::cAlphaArgs(1)); ErrorsFound = true; } else { - if (WaterEquipment(WaterEquipNum).Connections > 0) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).Connections > 0) { ShowSevereError(DataIPShortCuts::cCurrentModuleObject + " = " + DataIPShortCuts::cAlphaArgs(1) + ": WaterUse:Equipment = " + DataIPShortCuts::cAlphaArgs(AlphaNum) + " is already referenced by another object."); ErrorsFound = true; } else { - WaterEquipment(WaterEquipNum).Connections = WaterConnNum; + dataWaterUse.WaterEquipment(WaterEquipNum).Connections = WaterConnNum; - ++WaterConnections(WaterConnNum).NumWaterEquipment; - WaterConnections(WaterConnNum).myWaterEquipArr(WaterConnections(WaterConnNum).NumWaterEquipment) = WaterEquipNum; + ++dataWaterUse.WaterConnections(WaterConnNum).NumWaterEquipment; + dataWaterUse.WaterConnections(WaterConnNum).myWaterEquipArr(dataWaterUse.WaterConnections(WaterConnNum).NumWaterEquipment) = WaterEquipNum; - WaterConnections(WaterConnNum).PeakVolFlowRate += - WaterEquipment(WaterEquipNum).PeakVolFlowRate; // this does not include possible multipliers + dataWaterUse.WaterConnections(WaterConnNum).PeakVolFlowRate += + dataWaterUse.WaterEquipment(WaterEquipNum).PeakVolFlowRate; // this does not include possible multipliers } } } @@ -569,36 +550,36 @@ namespace WaterUse { if (ErrorsFound) ShowFatalError("Errors found in processing input for " + DataIPShortCuts::cCurrentModuleObject); - if (numWaterConnections > 0) { - CheckEquipName.allocate(numWaterConnections); - CheckEquipName = true; + if (dataWaterUse.numWaterConnections > 0) { + dataWaterUse.CheckEquipName.allocate(dataWaterUse.numWaterConnections); + dataWaterUse.CheckEquipName = true; } } // determine connection's peak mass flow rates. - if (numWaterConnections > 0) { - for (int WaterConnNum = 1; WaterConnNum <= numWaterConnections; ++WaterConnNum) { - WaterConnections(WaterConnNum).PeakMassFlowRate = 0.0; - for (int WaterEquipNum = 1; WaterEquipNum <= WaterConnections(WaterConnNum).NumWaterEquipment; ++WaterEquipNum) { - int thisWaterEquipNum = WaterConnections(WaterConnNum).myWaterEquipArr(WaterEquipNum); - if (WaterEquipment(thisWaterEquipNum).Zone > 0) { - WaterConnections(WaterConnNum).PeakMassFlowRate += - WaterEquipment(thisWaterEquipNum).PeakVolFlowRate * Psychrometrics::RhoH2O(DataGlobals::InitConvTemp) * - DataHeatBalance::Zone(WaterEquipment(thisWaterEquipNum).Zone).Multiplier * - DataHeatBalance::Zone(WaterEquipment(thisWaterEquipNum).Zone).ListMultiplier; + if (dataWaterUse.numWaterConnections > 0) { + for (int WaterConnNum = 1; WaterConnNum <= dataWaterUse.numWaterConnections; ++WaterConnNum) { + dataWaterUse.WaterConnections(WaterConnNum).PeakMassFlowRate = 0.0; + for (int WaterEquipNum = 1; WaterEquipNum <= dataWaterUse.WaterConnections(WaterConnNum).NumWaterEquipment; ++WaterEquipNum) { + int thisWaterEquipNum = dataWaterUse.WaterConnections(WaterConnNum).myWaterEquipArr(WaterEquipNum); + if (dataWaterUse.WaterEquipment(thisWaterEquipNum).Zone > 0) { + dataWaterUse.WaterConnections(WaterConnNum).PeakMassFlowRate += + dataWaterUse.WaterEquipment(thisWaterEquipNum).PeakVolFlowRate * Psychrometrics::RhoH2O(DataGlobals::InitConvTemp) * + DataHeatBalance::Zone(dataWaterUse.WaterEquipment(thisWaterEquipNum).Zone).Multiplier * + DataHeatBalance::Zone(dataWaterUse.WaterEquipment(thisWaterEquipNum).Zone).ListMultiplier; } else { // can't have multipliers - WaterConnections(WaterConnNum).PeakMassFlowRate += - WaterEquipment(thisWaterEquipNum).PeakVolFlowRate * Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); + dataWaterUse.WaterConnections(WaterConnNum).PeakMassFlowRate += + dataWaterUse.WaterEquipment(thisWaterEquipNum).PeakVolFlowRate * Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); } } - PlantUtilities::RegisterPlantCompDesignFlow(WaterConnections(WaterConnNum).InletNode, - WaterConnections(WaterConnNum).PeakMassFlowRate / + PlantUtilities::RegisterPlantCompDesignFlow(dataWaterUse.WaterConnections(WaterConnNum).InletNode, + dataWaterUse.WaterConnections(WaterConnNum).PeakMassFlowRate / Psychrometrics::RhoH2O(DataGlobals::InitConvTemp)); } } } - void WaterEquipmentType::setupOutputVars() + void WaterEquipmentType::setupOutputVars(WaterUseData &dataWaterUse) { SetupOutputVariable( "Water Use Equipment Hot Water Mass Flow Rate", OutputProcessor::Unit::kg_s, this->HotMassFlowRate, "System", "Average", this->Name); @@ -673,7 +654,7 @@ namespace WaterUse { this->EndUseSubcatName, "Plant"); - } else if (WaterConnections(this->Connections).StandAlone) { + } else if (dataWaterUse.WaterConnections(this->Connections).StandAlone) { SetupOutputVariable("Water Use Equipment Heating Energy", OutputProcessor::Unit::J, this->Energy, @@ -731,7 +712,7 @@ namespace WaterUse { } } - void WaterConnectionsType::setupOutputVars() + void WaterConnectionsType::setupOutputVars(WaterUseData &EP_UNUSED(dataWaterUse)) { SetupOutputVariable( "Water Use Connections Hot Water Mass Flow Rate", OutputProcessor::Unit::kg_s, this->HotMassFlowRate, "System", "Average", this->Name); @@ -817,7 +798,7 @@ namespace WaterUse { } } - void WaterEquipmentType::CalcEquipmentFlowRates() + void WaterEquipmentType::CalcEquipmentFlowRates(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -830,14 +811,14 @@ namespace WaterUse { // Calculate desired hot and cold water flow rates if (this->setupMyOutputVars) { - this->setupOutputVars(); + this->setupOutputVars(dataWaterUse); this->setupMyOutputVars = false; } if (this->Connections > 0) { // Get water temperature conditions from the CONNECTIONS object - this->ColdTemp = WaterConnections(this->Connections).ColdTemp; - this->HotTemp = WaterConnections(this->Connections).HotTemp; + this->ColdTemp = dataWaterUse.WaterConnections(this->Connections).ColdTemp; + this->HotTemp = dataWaterUse.WaterConnections(this->Connections).HotTemp; } else { // Get water temperature conditions from the WATER USE EQUIPMENT schedules @@ -978,7 +959,7 @@ namespace WaterUse { } } - void WaterConnectionsType::InitConnections(BranchInputManagerData &dataBranchInputManager) + void WaterConnectionsType::InitConnections(BranchInputManagerData &dataBranchInputManager, WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -988,7 +969,7 @@ namespace WaterUse { // RE-ENGINEERED na if (this->setupMyOutputVars) { - this->setupOutputVars(); + this->setupOutputVars(dataWaterUse); this->setupMyOutputVars = false; } @@ -1070,7 +1051,7 @@ namespace WaterUse { } } - void WaterConnectionsType::CalcConnectionsFlowRates(bool FirstHVACIteration) + void WaterConnectionsType::CalcConnectionsFlowRates(WaterUseData &dataWaterUse, bool FirstHVACIteration) { // SUBROUTINE INFORMATION: @@ -1088,10 +1069,10 @@ namespace WaterUse { for (int Loop = 1; Loop <= this->NumWaterEquipment; ++Loop) { int WaterEquipNum = this->myWaterEquipArr(Loop); - WaterEquipment(WaterEquipNum).CalcEquipmentFlowRates(); + dataWaterUse.WaterEquipment(WaterEquipNum).CalcEquipmentFlowRates(dataWaterUse); - this->ColdMassFlowRate += WaterEquipment(WaterEquipNum).ColdMassFlowRate; - this->HotMassFlowRate += WaterEquipment(WaterEquipNum).HotMassFlowRate; + this->ColdMassFlowRate += dataWaterUse.WaterEquipment(WaterEquipNum).ColdMassFlowRate; + this->HotMassFlowRate += dataWaterUse.WaterEquipment(WaterEquipNum).HotMassFlowRate; } // Loop this->TotalMassFlowRate = this->ColdMassFlowRate + this->HotMassFlowRate; @@ -1129,18 +1110,18 @@ namespace WaterUse { int WaterEquipNum = this->myWaterEquipArr(Loop); // Recalculate flow rates for water equipment within connection - WaterEquipment(WaterEquipNum).HotMassFlowRate *= AvailableFraction; - WaterEquipment(WaterEquipNum).ColdMassFlowRate = - WaterEquipment(WaterEquipNum).TotalMassFlowRate - WaterEquipment(WaterEquipNum).HotMassFlowRate; + dataWaterUse.WaterEquipment(WaterEquipNum).HotMassFlowRate *= AvailableFraction; + dataWaterUse.WaterEquipment(WaterEquipNum).ColdMassFlowRate = + dataWaterUse.WaterEquipment(WaterEquipNum).TotalMassFlowRate - dataWaterUse.WaterEquipment(WaterEquipNum).HotMassFlowRate; // Recalculate mixed water temperature - if (WaterEquipment(WaterEquipNum).TotalMassFlowRate > 0.0) { - WaterEquipment(WaterEquipNum).MixedTemp = - (WaterEquipment(WaterEquipNum).ColdMassFlowRate * WaterEquipment(WaterEquipNum).ColdTemp + - WaterEquipment(WaterEquipNum).HotMassFlowRate * WaterEquipment(WaterEquipNum).HotTemp) / - WaterEquipment(WaterEquipNum).TotalMassFlowRate; + if (dataWaterUse.WaterEquipment(WaterEquipNum).TotalMassFlowRate > 0.0) { + dataWaterUse.WaterEquipment(WaterEquipNum).MixedTemp = + (dataWaterUse.WaterEquipment(WaterEquipNum).ColdMassFlowRate * dataWaterUse.WaterEquipment(WaterEquipNum).ColdTemp + + dataWaterUse.WaterEquipment(WaterEquipNum).HotMassFlowRate * dataWaterUse.WaterEquipment(WaterEquipNum).HotTemp) / + dataWaterUse.WaterEquipment(WaterEquipNum).TotalMassFlowRate; } else { - WaterEquipment(WaterEquipNum).MixedTemp = WaterEquipment(WaterEquipNum).TargetTemp; + dataWaterUse.WaterEquipment(WaterEquipNum).MixedTemp = dataWaterUse.WaterEquipment(WaterEquipNum).TargetTemp; } } // Loop } @@ -1161,7 +1142,7 @@ namespace WaterUse { } } - void WaterConnectionsType::CalcConnectionsDrainTemp() + void WaterConnectionsType::CalcConnectionsDrainTemp(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -1176,10 +1157,10 @@ namespace WaterUse { for (int Loop = 1; Loop <= this->NumWaterEquipment; ++Loop) { int WaterEquipNum = this->myWaterEquipArr(Loop); - WaterEquipment(WaterEquipNum).CalcEquipmentDrainTemp(); + dataWaterUse.WaterEquipment(WaterEquipNum).CalcEquipmentDrainTemp(); - this->DrainMassFlowRate += WaterEquipment(WaterEquipNum).DrainMassFlowRate; - MassFlowTempSum += WaterEquipment(WaterEquipNum).DrainMassFlowRate * WaterEquipment(WaterEquipNum).DrainTemp; + this->DrainMassFlowRate += dataWaterUse.WaterEquipment(WaterEquipNum).DrainMassFlowRate; + MassFlowTempSum += dataWaterUse.WaterEquipment(WaterEquipNum).DrainMassFlowRate * dataWaterUse.WaterEquipment(WaterEquipNum).DrainTemp; } // Loop if (this->DrainMassFlowRate > 0.0) { @@ -1215,7 +1196,7 @@ namespace WaterUse { this->ReturnTemp = this->ColdSupplyTemp; this->WasteTemp = this->DrainTemp; - } else { // WaterConnections(WaterConnNum)%TotalMassFlowRate > 0.0 + } else { // dataWaterUse.WaterConnections(WaterConnNum)%TotalMassFlowRate > 0.0 { auto const SELECT_CASE_var(this->HeatRecoveryConfig); @@ -1309,7 +1290,7 @@ namespace WaterUse { } } - void ReportStandAloneWaterUse() + void ReportStandAloneWaterUse(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -1321,8 +1302,8 @@ namespace WaterUse { // PURPOSE OF THIS SUBROUTINE: // Calculates report variables for stand alone water use - for (int WaterEquipNum = 1; WaterEquipNum <= numWaterEquipment; ++WaterEquipNum) { - auto &thisWEq = WaterEquipment(WaterEquipNum); + for (int WaterEquipNum = 1; WaterEquipNum <= dataWaterUse.numWaterEquipment; ++WaterEquipNum) { + auto &thisWEq = dataWaterUse.WaterEquipment(WaterEquipNum); thisWEq.ColdVolFlowRate = thisWEq.ColdMassFlowRate / Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); thisWEq.HotVolFlowRate = thisWEq.HotMassFlowRate / Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); thisWEq.TotalVolFlowRate = thisWEq.ColdVolFlowRate + thisWEq.HotVolFlowRate; @@ -1335,14 +1316,14 @@ namespace WaterUse { thisWEq.Power = thisWEq.HotMassFlowRate * Psychrometrics::CPHW(DataGlobals::InitConvTemp) * (thisWEq.HotTemp - thisWEq.ColdTemp); } else { thisWEq.Power = thisWEq.HotMassFlowRate * Psychrometrics::CPHW(DataGlobals::InitConvTemp) * - (thisWEq.HotTemp - WaterConnections(thisWEq.Connections).ReturnTemp); + (thisWEq.HotTemp - dataWaterUse.WaterConnections(thisWEq.Connections).ReturnTemp); } thisWEq.Energy = thisWEq.Power * DataHVACGlobals::TimeStepSys * DataGlobals::SecInHour; } } - void WaterConnectionsType::ReportWaterUse() + void WaterConnectionsType::ReportWaterUse(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -1357,7 +1338,7 @@ namespace WaterUse { for (int Loop = 1; Loop <= this->NumWaterEquipment; ++Loop) { int WaterEquipNum = this->myWaterEquipArr(Loop); - auto &thisWEq = WaterEquipment(WaterEquipNum); + auto &thisWEq = dataWaterUse.WaterEquipment(WaterEquipNum); thisWEq.ColdVolFlowRate = thisWEq.ColdMassFlowRate / Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); thisWEq.HotVolFlowRate = thisWEq.HotMassFlowRate / Psychrometrics::RhoH2O(DataGlobals::InitConvTemp); @@ -1370,7 +1351,7 @@ namespace WaterUse { thisWEq.Power = thisWEq.HotMassFlowRate * Psychrometrics::CPHW(DataGlobals::InitConvTemp) * (thisWEq.HotTemp - thisWEq.ColdTemp); } else { thisWEq.Power = thisWEq.HotMassFlowRate * Psychrometrics::CPHW(DataGlobals::InitConvTemp) * - (thisWEq.HotTemp - WaterConnections(thisWEq.Connections).ReturnTemp); + (thisWEq.HotTemp - dataWaterUse.WaterConnections(thisWEq.Connections).ReturnTemp); } thisWEq.Energy = thisWEq.Power * DataHVACGlobals::TimeStepSys * DataGlobals::SecInHour; @@ -1387,7 +1368,7 @@ namespace WaterUse { this->RecoveryEnergy = this->RecoveryRate * DataHVACGlobals::TimeStepSys * DataGlobals::SecInHour; } - void CalcWaterUseZoneGains() + void CalcWaterUseZoneGains(WaterUseData &dataWaterUse) { // SUBROUTINE INFORMATION: @@ -1401,10 +1382,10 @@ namespace WaterUse { bool MyEnvrnFlagLocal(true); - if (numWaterEquipment == 0) return; + if (dataWaterUse.numWaterEquipment == 0) return; if (DataGlobals::BeginEnvrnFlag && MyEnvrnFlagLocal) { - for (auto &e : WaterEquipment) { + for (auto &e : dataWaterUse.WaterEquipment) { e.SensibleRate = 0.0; e.SensibleEnergy = 0.0; e.SensibleRateNoMultiplier = 0.0; @@ -1425,14 +1406,14 @@ namespace WaterUse { if (!DataGlobals::BeginEnvrnFlag) MyEnvrnFlagLocal = true; - for (int WaterEquipNum = 1; WaterEquipNum <= numWaterEquipment; ++WaterEquipNum) { - if (WaterEquipment(WaterEquipNum).Zone == 0) continue; - int ZoneNum = WaterEquipment(WaterEquipNum).Zone; - WaterEquipment(WaterEquipNum).SensibleRateNoMultiplier = - WaterEquipment(WaterEquipNum).SensibleRate / + for (int WaterEquipNum = 1; WaterEquipNum <= dataWaterUse.numWaterEquipment; ++WaterEquipNum) { + if (dataWaterUse.WaterEquipment(WaterEquipNum).Zone == 0) continue; + int ZoneNum = dataWaterUse.WaterEquipment(WaterEquipNum).Zone; + dataWaterUse.WaterEquipment(WaterEquipNum).SensibleRateNoMultiplier = + dataWaterUse.WaterEquipment(WaterEquipNum).SensibleRate / (DataHeatBalance::Zone(ZoneNum).Multiplier * DataHeatBalance::Zone(ZoneNum).ListMultiplier); - WaterEquipment(WaterEquipNum).LatentRateNoMultiplier = - WaterEquipment(WaterEquipNum).LatentRate / + dataWaterUse.WaterEquipment(WaterEquipNum).LatentRateNoMultiplier = + dataWaterUse.WaterEquipment(WaterEquipNum).LatentRate / (DataHeatBalance::Zone(ZoneNum).Multiplier * DataHeatBalance::Zone(ZoneNum).ListMultiplier); } } diff --git a/src/EnergyPlus/WaterUse.hh b/src/EnergyPlus/WaterUse.hh index 66b29f92122..1fa5b48e84a 100644 --- a/src/EnergyPlus/WaterUse.hh +++ b/src/EnergyPlus/WaterUse.hh @@ -52,6 +52,7 @@ #include // EnergyPlus Headers +#include #include #include #include @@ -61,6 +62,7 @@ namespace EnergyPlus { // Forward declarations struct EnergyPlusData; struct BranchInputManagerData; +struct WaterUseData; namespace WaterUse { @@ -78,10 +80,6 @@ namespace WaterUse { PlantAndEquip }; - extern bool getWaterUseInputFlag; - - extern Array1D_bool CheckEquipName; - struct WaterEquipmentType { std::string Name; // Name of DHW @@ -144,11 +142,11 @@ namespace WaterUse { DrainTemp = 0.0; } - void CalcEquipmentFlowRates(); + void CalcEquipmentFlowRates(WaterUseData &dataWaterUse); void CalcEquipmentDrainTemp(); - void setupOutputVars(); + void setupOutputVars(WaterUseData &dataWaterUse); }; struct WaterConnectionsType : PlantComponent @@ -229,40 +227,59 @@ namespace WaterUse { { } - static PlantComponent *factory(std::string const &objectName); + static PlantComponent *factory(WaterUseData &dataWaterUse, std::string const &objectName); void simulate(EnergyPlusData &EP_UNUSED(state), const PlantLocation &calledFromLocation, bool FirstHVACIteration, Real64 &CurLoad, bool RunFlag) override; - void InitConnections(BranchInputManagerData &state); + void InitConnections(BranchInputManagerData &dataBranchInputManager, WaterUseData &dataWaterUse); - void CalcConnectionsFlowRates(bool FirstHVACIteration); + void CalcConnectionsFlowRates(WaterUseData &dataWaterUse, bool FirstHVACIteration); - void CalcConnectionsDrainTemp(); + void CalcConnectionsDrainTemp(WaterUseData &dataWaterUse); void CalcConnectionsHeatRecovery(); void UpdateWaterConnections(); - void ReportWaterUse(); + void ReportWaterUse(WaterUseData &dataWaterUse); - void setupOutputVars(); + void setupOutputVars(WaterUseData &EP_UNUSED(dataWaterUse)); }; - void clear_state(); + void SimulateWaterUse(BranchInputManagerData &dataBranchInputManager, WaterUseData &dataWaterUse, bool FirstHVACIteration); - void SimulateWaterUse(BranchInputManagerData &dataBranchInputManager, bool FirstHVACIteration); + void GetWaterUseInput(WaterUseData &dataWaterUse); - void GetWaterUseInput(); + void ReportStandAloneWaterUse(WaterUseData &dataWaterUse); - void ReportStandAloneWaterUse(); + void CalcWaterUseZoneGains(WaterUseData &dataWaterUse); - void CalcWaterUseZoneGains(); +} // namespace WaterUse - extern Array1D WaterEquipment; + struct WaterUseData : BaseGlobalStruct { - extern Array1D WaterConnections; + int numWaterEquipment; + int numWaterConnections; + bool getWaterUseInputFlag; + Array1D_bool CheckEquipName; + Array1D WaterEquipment; + Array1D WaterConnections; -} // namespace WaterUse + void clear_state() override + { + numWaterEquipment = 0; + numWaterConnections = 0; + getWaterUseInputFlag = true; + CheckEquipName.deallocate(); + WaterEquipment.deallocate(); + WaterConnections.deallocate(); + } + + // Default Constructor + WaterUseData() : numWaterEquipment(0), numWaterConnections(0), getWaterUseInputFlag(true) + { + } + }; } // namespace EnergyPlus diff --git a/src/EnergyPlus/WindTurbine.cc b/src/EnergyPlus/WindTurbine.cc index f17598d2156..a2555a585bc 100644 --- a/src/EnergyPlus/WindTurbine.cc +++ b/src/EnergyPlus/WindTurbine.cc @@ -57,6 +57,7 @@ // EnergyPlus Headers #include +#include #include #include #include @@ -88,18 +89,12 @@ namespace WindTurbine { // This module is to calculate the electrical power output that wind turbine systems produce. // Both horizontal and vertical axis wind turbine systems are modeled. - // METHODOLOGY EMPLOYED: - // na - // REFERENCES: // Sathyajith Mathew. 2006. Wind Energy: Fundamental, Resource Analysis and Economics. Springer, // Chap. 2, pp. 11-15 // Mazharul Islam, David S.K. Ting, and Amir Fartaj. 2008. Aerodynamic Models for Darrieus-type sSraight-bladed // Vertical Axis Wind Turbines. Renewable & Sustainable Energy Reviews, Volume 12, pp.1087-1109 - // OTHER NOTES: none - - // Using/Aliasing using namespace DataPrecisionGlobals; using namespace DataGenerators; using DataGlobals::BeginEnvrnFlag; @@ -108,31 +103,11 @@ namespace WindTurbine { using DataGlobals::ScheduleAlwaysOn; using DataGlobals::SecInHour; - // Data - // MODULE PARAMETER DEFINITIONS - int const HAWT(1); // 'HorizontalAxisWindTurbine' - int const VAWT(2); // 'VerticalAxisWindTurbine' - - int const FSFP(1); // 'FixedSpeedFixedPitch' - int const FSVP(2); // 'FixedSpeedVariablePitch' - int const VSFP(3); // 'VariableSpeedFixedPitch' - int const VSVP(4); // 'VariableSpeedVariablePitch' - static std::string const BlankString; - // DERIVED TYPE DEFINITIONS - - // MODULE VARIABLES DECLARATIONS: - int NumWindTurbines(0); // Total wind turbine statements in inputs - - // Subroutine Specifications for the Heat Balance Module - - // Object Data - Array1D WindTurbineSys; - // Functions - void SimWindTurbine(int const EP_UNUSED(GeneratorType), // Type of Generator + void SimWindTurbine(WindTurbineData &dataWindTurbine, int const EP_UNUSED(GeneratorType), // Type of Generator std::string const &GeneratorName, // User specified name of Generator int &GeneratorIndex, // Generator index bool const RunFlag, // ON or OFF @@ -159,36 +134,36 @@ namespace WindTurbine { // Obtains and allocates heat balance related parameters from input if (GetInputFlag) { - GetWindTurbineInput(); + GetWindTurbineInput(dataWindTurbine); GetInputFlag = false; } if (GeneratorIndex == 0) { - WindTurbineNum = UtilityRoutines::FindItemInList(GeneratorName, WindTurbineSys); + WindTurbineNum = UtilityRoutines::FindItemInList(GeneratorName, dataWindTurbine.WindTurbineSys); if (WindTurbineNum == 0) { ShowFatalError("SimWindTurbine: Specified Generator not one of Valid Wind Turbine Generators " + GeneratorName); } GeneratorIndex = WindTurbineNum; } else { WindTurbineNum = GeneratorIndex; - if (WindTurbineNum > NumWindTurbines || WindTurbineNum < 1) { + if (WindTurbineNum > dataWindTurbine.NumWindTurbines || WindTurbineNum < 1) { ShowFatalError("SimWindTurbine: Invalid GeneratorIndex passed=" + TrimSigDigits(WindTurbineNum) + - ", Number of Wind Turbine Generators=" + TrimSigDigits(NumWindTurbines) + ", Generator name=" + GeneratorName); + ", Number of Wind Turbine Generators=" + TrimSigDigits(dataWindTurbine.NumWindTurbines) + ", Generator name=" + GeneratorName); } - if (GeneratorName != WindTurbineSys(WindTurbineNum).Name) { + if (GeneratorName != dataWindTurbine.WindTurbineSys(WindTurbineNum).Name) { ShowFatalError("SimMWindTurbine: Invalid GeneratorIndex passed=" + TrimSigDigits(WindTurbineNum) + - ", Generator name=" + GeneratorName + ", stored Generator Name for that index=" + WindTurbineSys(WindTurbineNum).Name); + ", Generator name=" + GeneratorName + ", stored Generator Name for that index=" + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); } } - InitWindTurbine(WindTurbineNum); + InitWindTurbine(dataWindTurbine, WindTurbineNum); - CalcWindTurbine(WindTurbineNum, RunFlag); + CalcWindTurbine(dataWindTurbine, WindTurbineNum, RunFlag); - ReportWindTurbine(WindTurbineNum); + ReportWindTurbine(dataWindTurbine, WindTurbineNum); } - void GetWTGeneratorResults(int const EP_UNUSED(GeneratorType), // Type of Generator + void GetWTGeneratorResults(WindTurbineData &dataWindTurbine, int const EP_UNUSED(GeneratorType), // Type of Generator int const GeneratorIndex, // Generator number Real64 &GeneratorPower, // Electrical power Real64 &GeneratorEnergy, // Electrical energy @@ -205,36 +180,15 @@ namespace WindTurbine { // PURPOSE OF THIS SUBROUTINE: // This subroutine provides a "get" method to collect results for individual electic load centers. - // METHODOLOGY EMPLOYED: - - // REFERENCES: - // na - - // USE STATEMENTS: - - // Locals - // SUBROUTINE ARGUMENT DEFINITIONS: - - // SUBROUTINE PARAMETER DEFINITIONS: - // na - - // INTERFACE BLOCK SPECIFICATIONS: - // na - - // DERIVED TYPE DEFINITIONS: - // na - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - - GeneratorPower = WindTurbineSys(GeneratorIndex).Power; - GeneratorEnergy = WindTurbineSys(GeneratorIndex).Energy; + GeneratorPower = dataWindTurbine.WindTurbineSys(GeneratorIndex).Power; + GeneratorEnergy = dataWindTurbine.WindTurbineSys(GeneratorIndex).Energy; // Thermal energy is ignored ThermalPower = 0.0; ThermalEnergy = 0.0; } - void GetWindTurbineInput() + void GetWindTurbineInput(WindTurbineData &dataWindTurbine) { // SUBROUTINE INFORMATION: @@ -282,12 +236,12 @@ namespace WindTurbine { lAlphaBlanks.dimension(NumAlphas, true); lNumericBlanks.dimension(NumNumbers, true); - NumWindTurbines = inputProcessor->getNumObjectsFound(CurrentModuleObject); + dataWindTurbine.NumWindTurbines = inputProcessor->getNumObjectsFound(CurrentModuleObject); - WindTurbineSys.allocate(NumWindTurbines); + dataWindTurbine.WindTurbineSys.allocate(dataWindTurbine.NumWindTurbines); // Flow - for (WindTurbineNum = 1; WindTurbineNum <= NumWindTurbines; ++WindTurbineNum) { + for (WindTurbineNum = 1; WindTurbineNum <= dataWindTurbine.NumWindTurbines; ++WindTurbineNum) { inputProcessor->getObjectItem(CurrentModuleObject, WindTurbineNum, @@ -302,14 +256,14 @@ namespace WindTurbine { cNumericFields); UtilityRoutines::IsNameEmpty(cAlphaArgs(1), CurrentModuleObject, ErrorsFound); - WindTurbineSys(WindTurbineNum).Name = cAlphaArgs(1); // Name of wind turbine + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name = cAlphaArgs(1); // Name of wind turbine - WindTurbineSys(WindTurbineNum).Schedule = cAlphaArgs(2); // Get schedule + dataWindTurbine.WindTurbineSys(WindTurbineNum).Schedule = cAlphaArgs(2); // Get schedule if (lAlphaBlanks(2)) { - WindTurbineSys(WindTurbineNum).SchedPtr = ScheduleAlwaysOn; + dataWindTurbine.WindTurbineSys(WindTurbineNum).SchedPtr = ScheduleAlwaysOn; } else { - WindTurbineSys(WindTurbineNum).SchedPtr = GetScheduleIndex(cAlphaArgs(2)); - if (WindTurbineSys(WindTurbineNum).SchedPtr == 0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).SchedPtr = GetScheduleIndex(cAlphaArgs(2)); + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).SchedPtr == 0) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cAlphaFields(2) + "=\"" + cAlphaArgs(2) + "\" not found."); ErrorsFound = true; @@ -319,9 +273,9 @@ namespace WindTurbine { { auto const SELECT_CASE_var(cAlphaArgs(3)); if ((SELECT_CASE_var == "HORIZONTALAXISWINDTURBINE") || (SELECT_CASE_var == "")) { - WindTurbineSys(WindTurbineNum).RotorType = HAWT; + dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType = RotorType::HAWT; } else if (SELECT_CASE_var == "VERTICALAXISWINDTURBINE") { - WindTurbineSys(WindTurbineNum).RotorType = VAWT; + dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType = RotorType::VAWT; } else { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cAlphaFields(3) + "=\"" + cAlphaArgs(3) + "\"."); ErrorsFound = true; @@ -332,21 +286,21 @@ namespace WindTurbine { { auto const SELECT_CASE_var(cAlphaArgs(4)); if (SELECT_CASE_var == "FIXEDSPEEDFIXEDPITCH") { - WindTurbineSys(WindTurbineNum).ControlType = FSFP; + dataWindTurbine.WindTurbineSys(WindTurbineNum).controlType = ControlType::FSFP; } else if (SELECT_CASE_var == "FIXEDSPEEDVARIABLEPITCH") { - WindTurbineSys(WindTurbineNum).ControlType = FSVP; + dataWindTurbine.WindTurbineSys(WindTurbineNum).controlType = ControlType::FSVP; } else if (SELECT_CASE_var == "VARIABLESPEEDFIXEDPITCH") { - WindTurbineSys(WindTurbineNum).ControlType = VSFP; + dataWindTurbine.WindTurbineSys(WindTurbineNum).controlType = ControlType::VSFP; } else if ((SELECT_CASE_var == "VARIABLESPEEDVARIABLEPITCH") || (SELECT_CASE_var == "")) { - WindTurbineSys(WindTurbineNum).ControlType = VSVP; + dataWindTurbine.WindTurbineSys(WindTurbineNum).controlType = ControlType::VSVP; } else { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cAlphaFields(4) + "=\"" + cAlphaArgs(4) + "\"."); ErrorsFound = true; } } - WindTurbineSys(WindTurbineNum).RatedRotorSpeed = rNumericArgs(1); // Maximum rotor speed in rpm - if (WindTurbineSys(WindTurbineNum).RatedRotorSpeed <= 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedRotorSpeed = rNumericArgs(1); // Maximum rotor speed in rpm + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedRotorSpeed <= 0.0) { if (lNumericBlanks(1)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(1) + " is required but input is blank."); @@ -357,8 +311,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).RotorDiameter = rNumericArgs(2); // Rotor diameter in m - if (WindTurbineSys(WindTurbineNum).RotorDiameter <= 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorDiameter = rNumericArgs(2); // Rotor diameter in m + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorDiameter <= 0.0) { if (lNumericBlanks(2)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(2) + " is required but input is blank."); @@ -369,8 +323,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).RotorHeight = rNumericArgs(3); // Overall height of the rotor - if (WindTurbineSys(WindTurbineNum).RotorHeight <= 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorHeight = rNumericArgs(3); // Overall height of the rotor + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorHeight <= 0.0) { if (lNumericBlanks(3)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(3) + " is required but input is blank."); @@ -381,15 +335,15 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).NumOfBlade = rNumericArgs(4); // Total number of blade - if (WindTurbineSys(WindTurbineNum).NumOfBlade == 0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).NumOfBlade = rNumericArgs(4); // Total number of blade + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).NumOfBlade == 0) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(4) + "=[" + RoundSigDigits(rNumericArgs(4), 0) + "] must be greater than zero."); ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).RatedPower = rNumericArgs(5); // Rated average power - if (WindTurbineSys(WindTurbineNum).RatedPower == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower = rNumericArgs(5); // Rated average power + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower == 0.0) { if (lNumericBlanks(5)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(5) + " is required but input is blank."); @@ -400,8 +354,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).RatedWindSpeed = rNumericArgs(6); // Rated wind speed - if (WindTurbineSys(WindTurbineNum).RatedWindSpeed == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedWindSpeed = rNumericArgs(6); // Rated wind speed + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedWindSpeed == 0.0) { if (lNumericBlanks(6)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(6) + " is required but input is blank."); @@ -412,8 +366,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).CutInSpeed = rNumericArgs(7); // Minimum wind speed for system operation - if (WindTurbineSys(WindTurbineNum).CutInSpeed == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).CutInSpeed = rNumericArgs(7); // Minimum wind speed for system operation + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).CutInSpeed == 0.0) { if (lNumericBlanks(7)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(7) + " is required but input is blank."); @@ -424,12 +378,12 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).CutOutSpeed = rNumericArgs(8); // Minimum wind speed for system operation - if (WindTurbineSys(WindTurbineNum).CutOutSpeed == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).CutOutSpeed = rNumericArgs(8); // Minimum wind speed for system operation + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).CutOutSpeed == 0.0) { if (lNumericBlanks(8)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(8) + " is required but input is blank."); - } else if (WindTurbineSys(WindTurbineNum).CutOutSpeed <= WindTurbineSys(WindTurbineNum).RatedWindSpeed) { + } else if (dataWindTurbine.WindTurbineSys(WindTurbineNum).CutOutSpeed <= dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedWindSpeed) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(8) + "=[" + RoundSigDigits(rNumericArgs(8), 2) + "] must be greater than " + cNumericFields(6) + "=[" + RoundSigDigits(rNumericArgs(6), 2) + "]."); @@ -440,16 +394,16 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).SysEfficiency = rNumericArgs(9); // Overall wind turbine system efficiency - if (lNumericBlanks(9) || WindTurbineSys(WindTurbineNum).SysEfficiency == 0.0 || WindTurbineSys(WindTurbineNum).SysEfficiency > 1.0) { - WindTurbineSys(WindTurbineNum).SysEfficiency = SysEffDefault; + dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency = rNumericArgs(9); // Overall wind turbine system efficiency + if (lNumericBlanks(9) || dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency == 0.0 || dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency > 1.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency = SysEffDefault; ShowWarningError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(9) + "=[" + RoundSigDigits(rNumericArgs(9), 2) + "]."); ShowContinueError("...The default value of " + RoundSigDigits(SysEffDefault, 3) + " for " + cNumericFields(9) + " was assumed."); } - WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio = rNumericArgs(10); // Maximum tip speed ratio - if (WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio = rNumericArgs(10); // Maximum tip speed ratio + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio == 0.0) { if (lNumericBlanks(10)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(10) + " is required but input is blank."); @@ -459,15 +413,15 @@ namespace WindTurbine { } ErrorsFound = true; } - if (WindTurbineSys(WindTurbineNum).SysEfficiency > MaxTSR) { - WindTurbineSys(WindTurbineNum).SysEfficiency = MaxTSR; + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency > MaxTSR) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency = MaxTSR; ShowWarningError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(10) + "=[" + RoundSigDigits(rNumericArgs(10), 2) + "]."); ShowContinueError("...The default value of " + RoundSigDigits(MaxTSR, 1) + " for " + cNumericFields(10) + " was assumed."); } - WindTurbineSys(WindTurbineNum).MaxPowerCoeff = rNumericArgs(11); // Maximum power coefficient - if (WindTurbineSys(WindTurbineNum).RotorType == HAWT && WindTurbineSys(WindTurbineNum).MaxPowerCoeff == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxPowerCoeff = rNumericArgs(11); // Maximum power coefficient + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType == RotorType::HAWT && dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxPowerCoeff == 0.0) { if (lNumericBlanks(11)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(11) + " is required but input is blank."); @@ -477,15 +431,15 @@ namespace WindTurbine { } ErrorsFound = true; } - if (WindTurbineSys(WindTurbineNum).MaxPowerCoeff > MaxPowerCoeff) { - WindTurbineSys(WindTurbineNum).MaxPowerCoeff = DefaultPC; + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxPowerCoeff > MaxPowerCoeff) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxPowerCoeff = DefaultPC; ShowWarningError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(11) + "=[" + RoundSigDigits(rNumericArgs(11), 2) + "]."); ShowContinueError("...The default value of " + RoundSigDigits(DefaultPC, 2) + " for " + cNumericFields(11) + " will be used."); } - WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS = rNumericArgs(12); // Local wind speed annually averaged - if (WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS = rNumericArgs(12); // Local wind speed annually averaged + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS == 0.0) { if (lNumericBlanks(12)) { ShowWarningError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(12) + " is necessary for accurate prediction but input is blank."); @@ -496,12 +450,12 @@ namespace WindTurbine { } } - WindTurbineSys(WindTurbineNum).HeightForLocalWS = rNumericArgs(13); // Height of local meteorological station - if (WindTurbineSys(WindTurbineNum).HeightForLocalWS == 0.0) { - if (WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS == 0.0) { - WindTurbineSys(WindTurbineNum).HeightForLocalWS = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).HeightForLocalWS = rNumericArgs(13); // Height of local meteorological station + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).HeightForLocalWS == 0.0) { + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).HeightForLocalWS = 0.0; } else { - WindTurbineSys(WindTurbineNum).HeightForLocalWS = DefaultH; + dataWindTurbine.WindTurbineSys(WindTurbineNum).HeightForLocalWS = DefaultH; if (lNumericBlanks(13)) { ShowWarningError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(13) + " is necessary for accurate prediction but input is blank."); @@ -514,8 +468,8 @@ namespace WindTurbine { } } - WindTurbineSys(WindTurbineNum).ChordArea = rNumericArgs(14); // Chord area of a single blade for VAWTs - if (WindTurbineSys(WindTurbineNum).RotorType == VAWT && WindTurbineSys(WindTurbineNum).ChordArea == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordArea = rNumericArgs(14); // Chord area of a single blade for VAWTs + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType == RotorType::VAWT && dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordArea == 0.0) { if (lNumericBlanks(14)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(14) + " is required but input is blank."); @@ -526,8 +480,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).DragCoeff = rNumericArgs(15); // Blade drag coefficient - if (WindTurbineSys(WindTurbineNum).RotorType == VAWT && WindTurbineSys(WindTurbineNum).DragCoeff == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).DragCoeff = rNumericArgs(15); // Blade drag coefficient + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType == RotorType::VAWT && dataWindTurbine.WindTurbineSys(WindTurbineNum).DragCoeff == 0.0) { if (lNumericBlanks(15)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(15) + " is required but input is blank."); @@ -538,8 +492,8 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).LiftCoeff = rNumericArgs(16); // Blade lift coefficient - if (WindTurbineSys(WindTurbineNum).RotorType == VAWT && WindTurbineSys(WindTurbineNum).LiftCoeff == 0.0) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).LiftCoeff = rNumericArgs(16); // Blade lift coefficient + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType == RotorType::VAWT && dataWindTurbine.WindTurbineSys(WindTurbineNum).LiftCoeff == 0.0) { if (lNumericBlanks(16)) { ShowSevereError(CurrentModuleObject + "=\"" + cAlphaArgs(1) + "\" invalid " + cNumericFields(16) + " is required but input is blank."); @@ -550,29 +504,29 @@ namespace WindTurbine { ErrorsFound = true; } - WindTurbineSys(WindTurbineNum).PowerCoeffC1 = rNumericArgs(17); // Empirical power coefficient C1 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC1 = rNumericArgs(17); // Empirical power coefficient C1 if (lNumericBlanks(17)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC1 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC1 = 0.0; } - WindTurbineSys(WindTurbineNum).PowerCoeffC2 = rNumericArgs(18); // Empirical power coefficient C2 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC2 = rNumericArgs(18); // Empirical power coefficient C2 if (lNumericBlanks(18)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC2 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC2 = 0.0; } - WindTurbineSys(WindTurbineNum).PowerCoeffC3 = rNumericArgs(19); // Empirical power coefficient C3 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC3 = rNumericArgs(19); // Empirical power coefficient C3 if (lNumericBlanks(19)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC3 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC3 = 0.0; } - WindTurbineSys(WindTurbineNum).PowerCoeffC4 = rNumericArgs(20); // Empirical power coefficient C4 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC4 = rNumericArgs(20); // Empirical power coefficient C4 if (lNumericBlanks(20)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC4 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC4 = 0.0; } - WindTurbineSys(WindTurbineNum).PowerCoeffC5 = rNumericArgs(21); // Empirical power coefficient C5 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC5 = rNumericArgs(21); // Empirical power coefficient C5 if (lNumericBlanks(21)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC5 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC5 = 0.0; } - WindTurbineSys(WindTurbineNum).PowerCoeffC6 = rNumericArgs(22); // Empirical power coefficient C6 + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC6 = rNumericArgs(22); // Empirical power coefficient C6 if (lNumericBlanks(22)) { - WindTurbineSys(WindTurbineNum).PowerCoeffC6 = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC6 = 0.0; } } @@ -585,19 +539,19 @@ namespace WindTurbine { if (ErrorsFound) ShowFatalError(CurrentModuleObject + " errors occurred in input. Program terminates."); - for (WindTurbineNum = 1; WindTurbineNum <= NumWindTurbines; ++WindTurbineNum) { + for (WindTurbineNum = 1; WindTurbineNum <= dataWindTurbine.NumWindTurbines; ++WindTurbineNum) { SetupOutputVariable("Generator Produced Electric Power", OutputProcessor::Unit::W, - WindTurbineSys(WindTurbineNum).Power, + dataWindTurbine.WindTurbineSys(WindTurbineNum).Power, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Produced Electric Energy", OutputProcessor::Unit::J, - WindTurbineSys(WindTurbineNum).Energy, + dataWindTurbine.WindTurbineSys(WindTurbineNum).Energy, "System", "Sum", - WindTurbineSys(WindTurbineNum).Name, + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name, _, "ElectricityProduced", "WINDTURBINE", @@ -605,62 +559,62 @@ namespace WindTurbine { "Plant"); SetupOutputVariable("Generator Turbine Local Wind Speed", OutputProcessor::Unit::m_s, - WindTurbineSys(WindTurbineNum).LocalWindSpeed, + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalWindSpeed, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Turbine Local Air Density", OutputProcessor::Unit::kg_m3, - WindTurbineSys(WindTurbineNum).LocalAirDensity, + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAirDensity, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Turbine Tip Speed Ratio", OutputProcessor::Unit::None, - WindTurbineSys(WindTurbineNum).TipSpeedRatio, + dataWindTurbine.WindTurbineSys(WindTurbineNum).TipSpeedRatio, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); { - auto const SELECT_CASE_var(WindTurbineSys(WindTurbineNum).RotorType); - if (SELECT_CASE_var == HAWT) { + auto const SELECT_CASE_var(dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType); + if (SELECT_CASE_var == RotorType::HAWT) { SetupOutputVariable("Generator Turbine Power Coefficient", OutputProcessor::Unit::None, - WindTurbineSys(WindTurbineNum).PowerCoeff, + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeff, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); - } else if (SELECT_CASE_var == VAWT) { + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); + } else if (SELECT_CASE_var == RotorType::VAWT) { SetupOutputVariable("Generator Turbine Chordal Component Velocity", OutputProcessor::Unit::m_s, - WindTurbineSys(WindTurbineNum).ChordalVel, + dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordalVel, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Turbine Normal Component Velocity", OutputProcessor::Unit::m_s, - WindTurbineSys(WindTurbineNum).NormalVel, + dataWindTurbine.WindTurbineSys(WindTurbineNum).NormalVel, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Turbine Relative Flow Velocity", OutputProcessor::Unit::m_s, - WindTurbineSys(WindTurbineNum).RelFlowVel, + dataWindTurbine.WindTurbineSys(WindTurbineNum).RelFlowVel, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); SetupOutputVariable("Generator Turbine Attack Angle", OutputProcessor::Unit::deg, - WindTurbineSys(WindTurbineNum).AngOfAttack, + dataWindTurbine.WindTurbineSys(WindTurbineNum).AngOfAttack, "System", "Average", - WindTurbineSys(WindTurbineNum).Name); + dataWindTurbine.WindTurbineSys(WindTurbineNum).Name); } } } } - void InitWindTurbine(int const WindTurbineNum) + void InitWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum) { // SUBROUTINE INFORMATION: @@ -678,29 +632,13 @@ namespace WindTurbine { // at the particular rotor height is used with no factorization. // It also initializes module variables at each time step. - // METHODOLOGY EMPLOYED: - - // REFERENCES: - - // Using/Aliasing using DataEnvironment::SiteWindBLHeight; using DataEnvironment::SiteWindExp; using DataEnvironment::WeatherFileWindModCoeff; - // Locals - // SUBROUTINE ARGUMENT DEFINITIONS: - - // SUBROUTINE PARAMETER DEFINITIONS: static char const TabChr('\t'); // Tab character static ObjexxFCL::gio::Fmt fmtA("(A)"); - // INTERFACE BLOCK SPECIFICATIONS - // na - - // DERIVED TYPE DEFINITIONS - // na - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: static bool MyOneTimeFlag(true); int ReadStatus; // Reading status of stat file int statFile; // Weather Stat File @@ -800,33 +738,33 @@ namespace WindTurbine { MyOneTimeFlag = false; } - WindTurbineSys(WindTurbineNum).AnnualTMYWS = AnnualTMYWS; + dataWindTurbine.WindTurbineSys(WindTurbineNum).AnnualTMYWS = AnnualTMYWS; // Factor differences between TMY wind data and local wind data once - if (AnnualTMYWS > 0.0 && WindTurbineSys(WindTurbineNum).WSFactor == 0.0 && WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS > 0) { + if (AnnualTMYWS > 0.0 && dataWindTurbine.WindTurbineSys(WindTurbineNum).WSFactor == 0.0 && dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS > 0) { // Convert the annual wind speed to the local wind speed at the height of the local station, then factor LocalTMYWS = - AnnualTMYWS * WeatherFileWindModCoeff * std::pow(WindTurbineSys(WindTurbineNum).HeightForLocalWS / SiteWindBLHeight, SiteWindExp); - WindTurbineSys(WindTurbineNum).WSFactor = LocalTMYWS / WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS; + AnnualTMYWS * WeatherFileWindModCoeff * std::pow(dataWindTurbine.WindTurbineSys(WindTurbineNum).HeightForLocalWS / SiteWindBLHeight, SiteWindExp); + dataWindTurbine.WindTurbineSys(WindTurbineNum).WSFactor = LocalTMYWS / dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAnnualAvgWS; } // Assign factor of 1.0 if no stat file or no input of local average wind speed - if (WindTurbineSys(WindTurbineNum).WSFactor == 0.0) WindTurbineSys(WindTurbineNum).WSFactor = 1.0; + if (dataWindTurbine.WindTurbineSys(WindTurbineNum).WSFactor == 0.0) dataWindTurbine.WindTurbineSys(WindTurbineNum).WSFactor = 1.0; // Do every time step initialization - WindTurbineSys(WindTurbineNum).Power = 0.0; - WindTurbineSys(WindTurbineNum).TotPower = 0.0; - WindTurbineSys(WindTurbineNum).PowerCoeff = 0.0; - WindTurbineSys(WindTurbineNum).TipSpeedRatio = 0.0; - WindTurbineSys(WindTurbineNum).ChordalVel = 0.0; - WindTurbineSys(WindTurbineNum).NormalVel = 0.0; - WindTurbineSys(WindTurbineNum).RelFlowVel = 0.0; - WindTurbineSys(WindTurbineNum).AngOfAttack = 0.0; - WindTurbineSys(WindTurbineNum).TanForce = 0.0; - WindTurbineSys(WindTurbineNum).NorForce = 0.0; - WindTurbineSys(WindTurbineNum).TotTorque = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).Power = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotPower = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeff = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TipSpeedRatio = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordalVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NormalVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).RelFlowVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).AngOfAttack = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TanForce = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NorForce = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotTorque = 0.0; } - void CalcWindTurbine(int const WindTurbineNum, // System is on + void CalcWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum, // System is on bool const EP_UNUSED(RunFlag) // System is on ) { @@ -837,18 +775,12 @@ namespace WindTurbine { // MODIFIED na // RE-ENGINEERED na - // PURPOSE OF THIS SUBROUTINE: - - // METHODOLOGY EMPLOYED: - // na - // REFERENCES: // Sathyajith Mathew. 2006. Wind Energy: Fundamental, Resource Analysis and Economics. Springer, // Chap. 2, pp. 11-15 // Mazharul Islam, David S.K. Ting, and Amir Fartaj. 2008. Aerodynamic Models for Darrieus-type sSraight-bladed // Vertical Axis Wind Turbines. Renewable & Sustainable Energy Reviews, Volume 12, pp.1087-1109 - // Using/Aliasing using DataEnvironment::OutBaroPressAt; using DataEnvironment::OutDryBulbTempAt; using DataEnvironment::OutWetBulbTempAt; @@ -857,21 +789,10 @@ namespace WindTurbine { using Psychrometrics::PsyWFnTdbTwbPb; using ScheduleManager::GetCurrentScheduleValue; - // Locals - // SUBROUTINE ARGUMENT DEFINITIONS: - - // SUBROUTINE PARAMETER DEFINITIONS: Real64 const MaxTheta(90.0); // Maximum of theta Real64 const MaxDegree(360.0); // Maximum limit of outdoor air wind speed in m/s Real64 const SecInMin(60.0); - // INTERFACE BLOCK SPECIFICATIONS - // na - - // DERIVED TYPE DEFINITIONS - // na - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 LocalWindSpeed; // Ambient wind speed at the specific height in m/s Real64 RotorH; // Height of the rotor in m Real64 RotorD; // Diameter of the rotor in m @@ -913,20 +834,20 @@ namespace WindTurbine { Real64 RotorSpeed; // Speed of rotors // Estimate local velocity and density - RotorH = WindTurbineSys(WindTurbineNum).RotorHeight; - RotorD = WindTurbineSys(WindTurbineNum).RotorDiameter; - RotorSpeed = WindTurbineSys(WindTurbineNum).RatedRotorSpeed; + RotorH = dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorHeight; + RotorD = dataWindTurbine.WindTurbineSys(WindTurbineNum).RotorDiameter; + RotorSpeed = dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedRotorSpeed; LocalTemp = OutDryBulbTempAt(RotorH); LocalPress = OutBaroPressAt(RotorH); LocalHumRat = PsyWFnTdbTwbPb(LocalTemp, OutWetBulbTempAt(RotorH), LocalPress); LocalAirDensity = PsyRhoAirFnPbTdbW(LocalPress, LocalTemp, LocalHumRat); LocalWindSpeed = WindSpeedAt(RotorH); - LocalWindSpeed /= WindTurbineSys(WindTurbineNum).WSFactor; + LocalWindSpeed /= dataWindTurbine.WindTurbineSys(WindTurbineNum).WSFactor; // Flow // Check wind conditions for system operation - if (GetCurrentScheduleValue(WindTurbineSys(WindTurbineNum).SchedPtr) > 0 && LocalWindSpeed > WindTurbineSys(WindTurbineNum).CutInSpeed && - LocalWindSpeed < WindTurbineSys(WindTurbineNum).CutOutSpeed) { + if (GetCurrentScheduleValue(dataWindTurbine.WindTurbineSys(WindTurbineNum).SchedPtr) > 0 && LocalWindSpeed > dataWindTurbine.WindTurbineSys(WindTurbineNum).CutInSpeed && + LocalWindSpeed < dataWindTurbine.WindTurbineSys(WindTurbineNum).CutOutSpeed) { // System is on Period = 2.0 * Pi; @@ -935,22 +856,22 @@ namespace WindTurbine { TipSpeedRatio = (Omega * (RotorD / 2.0)) / LocalWindSpeed; // Limit maximum tip speed ratio - if (TipSpeedRatio > WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio) { - TipSpeedRatio = WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio; + if (TipSpeedRatio > dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio) { + TipSpeedRatio = dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio; } { - auto const SELECT_CASE_var(WindTurbineSys(WindTurbineNum).RotorType); - if (SELECT_CASE_var == HAWT) { // Horizontal axis wind turbine + auto const SELECT_CASE_var(dataWindTurbine.WindTurbineSys(WindTurbineNum).rotorType); + if (SELECT_CASE_var == RotorType::HAWT) { // Horizontal axis wind turbine - MaxPowerCoeff = WindTurbineSys(WindTurbineNum).MaxPowerCoeff; + MaxPowerCoeff = dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxPowerCoeff; // Check if empirical constants are available - C1 = WindTurbineSys(WindTurbineNum).PowerCoeffC1; - C2 = WindTurbineSys(WindTurbineNum).PowerCoeffC2; - C3 = WindTurbineSys(WindTurbineNum).PowerCoeffC3; - C4 = WindTurbineSys(WindTurbineNum).PowerCoeffC4; - C5 = WindTurbineSys(WindTurbineNum).PowerCoeffC5; - C6 = WindTurbineSys(WindTurbineNum).PowerCoeffC6; + C1 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC1; + C2 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC2; + C3 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC3; + C4 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC4; + C5 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC5; + C6 = dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeffC6; Real64 const LocalWindSpeed_3(pow_3(LocalWindSpeed)); if (C1 > 0.0 && C2 > 0.0 && C3 > 0.0 && C4 >= 0.0 && C5 > 0.0 && C6 > 0.0) { @@ -971,22 +892,22 @@ namespace WindTurbine { PowerCoeff = MaxPowerCoeff; } // Maximum of rated power - if (LocalWindSpeed >= WindTurbineSys(WindTurbineNum).RatedWindSpeed || WTPower > WindTurbineSys(WindTurbineNum).RatedPower) { - WTPower = WindTurbineSys(WindTurbineNum).RatedPower; + if (LocalWindSpeed >= dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedWindSpeed || WTPower > dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower) { + WTPower = dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower; PowerCoeff = WTPower / (0.5 * LocalAirDensity * SweptArea * LocalWindSpeed_3); } // Recalculated Cp at the rated power - WindTurbineSys(WindTurbineNum).PowerCoeff = PowerCoeff; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeff = PowerCoeff; - } else if (SELECT_CASE_var == VAWT) { // Vertical axis wind turbine + } else if (SELECT_CASE_var == RotorType::VAWT) { // Vertical axis wind turbine RotorVel = Omega * (RotorD / 2.0); // Recalculated omega, if TSR is greater than the maximum - if (TipSpeedRatio >= WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio) { - RotorVel = LocalWindSpeed * WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio; + if (TipSpeedRatio >= dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio) { + RotorVel = LocalWindSpeed * dataWindTurbine.WindTurbineSys(WindTurbineNum).MaxTipSpeedRatio; Omega = RotorVel / (RotorD / 2.0); } - AzimuthAng = MaxDegree / WindTurbineSys(WindTurbineNum).NumOfBlade; + AzimuthAng = MaxDegree / dataWindTurbine.WindTurbineSys(WindTurbineNum).NumOfBlade; // Azimuth angle between zero and 90 degree if (AzimuthAng > MaxTheta) { // Number of blades is 2 or 3 AzimuthAng -= MaxTheta; @@ -1011,14 +932,14 @@ namespace WindTurbine { // Force coefficients Real64 const sin_AngOfAttack(std::sin(AngOfAttack * DegToRadians)); Real64 const cos_AngOfAttack(std::cos(AngOfAttack * DegToRadians)); - TanForceCoeff = std::abs(WindTurbineSys(WindTurbineNum).LiftCoeff * sin_AngOfAttack - - WindTurbineSys(WindTurbineNum).DragCoeff * cos_AngOfAttack); + TanForceCoeff = std::abs(dataWindTurbine.WindTurbineSys(WindTurbineNum).LiftCoeff * sin_AngOfAttack - + dataWindTurbine.WindTurbineSys(WindTurbineNum).DragCoeff * cos_AngOfAttack); NorForceCoeff = - WindTurbineSys(WindTurbineNum).LiftCoeff * cos_AngOfAttack + WindTurbineSys(WindTurbineNum).DragCoeff * sin_AngOfAttack; + dataWindTurbine.WindTurbineSys(WindTurbineNum).LiftCoeff * cos_AngOfAttack + dataWindTurbine.WindTurbineSys(WindTurbineNum).DragCoeff * sin_AngOfAttack; // Net tangential and normal forces Real64 const RelFlowVel_2(pow_2(RelFlowVel)); - Real64 const density_fac(0.5 * LocalAirDensity * WindTurbineSys(WindTurbineNum).ChordArea * RelFlowVel_2); + Real64 const density_fac(0.5 * LocalAirDensity * dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordArea * RelFlowVel_2); TanForce = TanForceCoeff * density_fac; NorForce = NorForceCoeff * density_fac; Constant = (1.0 / Period) * (TanForce / RelFlowVel_2); @@ -1030,57 +951,57 @@ namespace WindTurbine { // Average tangential force on a single blade AvgTanForce = Constant * IntRelFlowVel; - TotTorque = WindTurbineSys(WindTurbineNum).NumOfBlade * AvgTanForce * (RotorD / 2.0); + TotTorque = dataWindTurbine.WindTurbineSys(WindTurbineNum).NumOfBlade * AvgTanForce * (RotorD / 2.0); WTPower = TotTorque * Omega; // Check if power produced is greater than maximum or rated power - if (WTPower > WindTurbineSys(WindTurbineNum).RatedPower) { - WTPower = WindTurbineSys(WindTurbineNum).RatedPower; + if (WTPower > dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower) { + WTPower = dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower; } - WindTurbineSys(WindTurbineNum).ChordalVel = ChordalVel; - WindTurbineSys(WindTurbineNum).NormalVel = NormalVel; - WindTurbineSys(WindTurbineNum).RelFlowVel = RelFlowVel; - WindTurbineSys(WindTurbineNum).TanForce = TanForce; - WindTurbineSys(WindTurbineNum).NorForce = NorForce; - WindTurbineSys(WindTurbineNum).TotTorque = TotTorque; + dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordalVel = ChordalVel; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NormalVel = NormalVel; + dataWindTurbine.WindTurbineSys(WindTurbineNum).RelFlowVel = RelFlowVel; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TanForce = TanForce; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NorForce = NorForce; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotTorque = TotTorque; } else { assert(false); } } - if (WTPower > WindTurbineSys(WindTurbineNum).RatedPower) { - WTPower = WindTurbineSys(WindTurbineNum).RatedPower; + if (WTPower > dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower) { + WTPower = dataWindTurbine.WindTurbineSys(WindTurbineNum).RatedPower; } // Actual power generated by the wind turbine system - Power = WTPower * WindTurbineSys(WindTurbineNum).SysEfficiency; + Power = WTPower * dataWindTurbine.WindTurbineSys(WindTurbineNum).SysEfficiency; - WindTurbineSys(WindTurbineNum).Power = Power; - WindTurbineSys(WindTurbineNum).TotPower = WTPower; - WindTurbineSys(WindTurbineNum).LocalWindSpeed = LocalWindSpeed; - WindTurbineSys(WindTurbineNum).LocalAirDensity = LocalAirDensity; - WindTurbineSys(WindTurbineNum).TipSpeedRatio = TipSpeedRatio; + dataWindTurbine.WindTurbineSys(WindTurbineNum).Power = Power; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotPower = WTPower; + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalWindSpeed = LocalWindSpeed; + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAirDensity = LocalAirDensity; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TipSpeedRatio = TipSpeedRatio; } else { // System is off - WindTurbineSys(WindTurbineNum).Power = 0.0; - WindTurbineSys(WindTurbineNum).TotPower = 0.0; - WindTurbineSys(WindTurbineNum).PowerCoeff = 0.0; - WindTurbineSys(WindTurbineNum).LocalWindSpeed = LocalWindSpeed; - WindTurbineSys(WindTurbineNum).LocalAirDensity = LocalAirDensity; - WindTurbineSys(WindTurbineNum).TipSpeedRatio = 0.0; - WindTurbineSys(WindTurbineNum).ChordalVel = 0.0; - WindTurbineSys(WindTurbineNum).NormalVel = 0.0; - WindTurbineSys(WindTurbineNum).RelFlowVel = 0.0; - WindTurbineSys(WindTurbineNum).AngOfAttack = 0.0; - WindTurbineSys(WindTurbineNum).TanForce = 0.0; - WindTurbineSys(WindTurbineNum).NorForce = 0.0; - WindTurbineSys(WindTurbineNum).TotTorque = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).Power = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotPower = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).PowerCoeff = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalWindSpeed = LocalWindSpeed; + dataWindTurbine.WindTurbineSys(WindTurbineNum).LocalAirDensity = LocalAirDensity; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TipSpeedRatio = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).ChordalVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NormalVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).RelFlowVel = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).AngOfAttack = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TanForce = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).NorForce = 0.0; + dataWindTurbine.WindTurbineSys(WindTurbineNum).TotTorque = 0.0; } } - void ReportWindTurbine(int const WindTurbineNum) + void ReportWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum) { // SUBROUTINE INFORMATION: // AUTHOR Daeho Kang @@ -1091,29 +1012,9 @@ namespace WindTurbine { // PURPOSE OF THIS SUBROUTINE: // This subroutine fills remaining report variables. - // METHODOLOGY EMPLOYED: - // na - - // REFERENCES: - // na - - // Using/Aliasing using DataHVACGlobals::TimeStepSys; - // Locals - // SUBROUTINE ARGUMENT DEFINITIONS: - // SUBROUTINE PARAMETER DEFINITIONS: - // na - - // INTERFACE BLOCK SPECIFICATIONS - // na - - // DERIVED TYPE DEFINITIONS - // na - - // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - - WindTurbineSys(WindTurbineNum).Energy = WindTurbineSys(WindTurbineNum).Power * TimeStepSys * SecInHour; + dataWindTurbine.WindTurbineSys(WindTurbineNum).Energy = dataWindTurbine.WindTurbineSys(WindTurbineNum).Power * TimeStepSys * SecInHour; } //***************************************************************************************** diff --git a/src/EnergyPlus/WindTurbine.hh b/src/EnergyPlus/WindTurbine.hh index 3bb2ff62228..ecc532ec588 100644 --- a/src/EnergyPlus/WindTurbine.hh +++ b/src/EnergyPlus/WindTurbine.hh @@ -52,43 +52,36 @@ #include // EnergyPlus Headers +#include #include #include namespace EnergyPlus { - -// (ref: Object: Generator:WindTurbine) + // Forward declarations + struct EnergyPlusData; + struct WindTurbineData; namespace WindTurbine { - // Using/Aliasing - - // Data - // MODULE PARAMETER DEFINITIONS - extern int const HAWT; // 'HorizontalAxisWindTurbine' - extern int const VAWT; // 'VerticalAxisWindTurbine' - - extern int const FSFP; // 'FixedSpeedFixedPitch' - extern int const FSVP; // 'FixedSpeedVariablePitch' - extern int const VSFP; // 'VariableSpeedFixedPitch' - extern int const VSVP; // 'VariableSpeedVariablePitch' - - // DERIVED TYPE DEFINITIONS - - // MODULE VARIABLES DECLARATIONS: - extern int NumWindTurbines; // Total wind turbine statements in inputs - - // Subroutine Specifications for the Heat Balance Module + enum class RotorType { + HAWT = 1, // 'HorizontalAxisWindTurbine' + VAWT = 2, // 'VerticalAxisWindTurbine' + }; - // Types + enum class ControlType { + FSFP = 1, // 'FixedSpeedFixedPitch' + FSVP = 2, // 'FixedSpeedVariablePitch' + VSFP = 3, // 'VariableSpeedFixedPitch' + VSVP = 4 // 'VariableSpeedVariablePitch' + }; struct WindTurbineParams { // Members std::string Name; // The component name std::string Schedule; // Available schedule - int RotorType; // Rotor type (HAWT or VAWT) - int ControlType; // Control type + RotorType rotorType; // Rotor type (HAWT or VAWT) + ControlType controlType; // Control type int SchedPtr; // Schedule int NumOfBlade; // Blade number Real64 RatedRotorSpeed; // Rated rotor speed in m/s @@ -134,7 +127,7 @@ namespace WindTurbine { // Default Constructor WindTurbineParams() - : RotorType(0), ControlType(0), SchedPtr(0), NumOfBlade(0), RatedRotorSpeed(0.0), RotorDiameter(0.0), RotorHeight(0.0), RatedPower(0.0), + : SchedPtr(0), NumOfBlade(0), RatedRotorSpeed(0.0), RotorDiameter(0.0), RotorHeight(0.0), RatedPower(0.0), RatedWindSpeed(0.0), CutInSpeed(0.0), CutOutSpeed(0.0), SysEfficiency(0.0), MaxTipSpeedRatio(0.0), MaxPowerCoeff(0.0), LocalAnnualAvgWS(0.0), AnnualTMYWS(0.0), HeightForLocalWS(0.0), ChordArea(0.0), DragCoeff(0.0), LiftCoeff(0.0), PowerCoeffC1(0.0), PowerCoeffC2(0.0), PowerCoeffC3(0.0), PowerCoeffC4(0.0), PowerCoeffC5(0.0), PowerCoeffC6(0.0), TotPower(0.0), Power(0.0), @@ -145,39 +138,54 @@ namespace WindTurbine { } }; - // Object Data - extern Array1D WindTurbineSys; - // Functions - void SimWindTurbine(int const GeneratorType, // Type of Generator + void SimWindTurbine(WindTurbineData &dataWindTurbine, int const GeneratorType, // Type of Generator std::string const &GeneratorName, // User specified name of Generator int &GeneratorIndex, // Generator index bool const RunFlag, // ON or OFF Real64 const WTLoad // Electrical load on WT (not used) ); - void GetWTGeneratorResults(int const GeneratorType, // Type of Generator + void GetWTGeneratorResults(WindTurbineData &dataWindTurbine, int const GeneratorType, // Type of Generator int const GeneratorIndex, // Generator number Real64 &GeneratorPower, // Electrical power Real64 &GeneratorEnergy, // Electrical energy Real64 &ThermalPower, Real64 &ThermalEnergy); - void GetWindTurbineInput(); + void GetWindTurbineInput(WindTurbineData &dataWindTurbine); - void InitWindTurbine(int const WindTurbineNum); + void InitWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum); - void CalcWindTurbine(int const WindTurbineNum, // System is on + void CalcWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum, // System is on bool const RunFlag // System is on ); - void ReportWindTurbine(int const WindTurbineNum); + void ReportWindTurbine(WindTurbineData &dataWindTurbine, int const WindTurbineNum); //***************************************************************************************** } // namespace WindTurbine + struct WindTurbineData : BaseGlobalStruct { + + + int NumWindTurbines; // Total wind turbine statements in inputs + Array1D WindTurbineSys; + + void clear_state() override + { + NumWindTurbines = 0; + WindTurbineSys.deallocate(); + } + + // Default Constructor + WindTurbineData() : NumWindTurbines(0) + { + } + }; + } // namespace EnergyPlus #endif diff --git a/src/EnergyPlus/WindowAC.hh b/src/EnergyPlus/WindowAC.hh index 06c5cbb603c..b16125f2fde 100644 --- a/src/EnergyPlus/WindowAC.hh +++ b/src/EnergyPlus/WindowAC.hh @@ -52,6 +52,7 @@ #include // EnergyPlus Headers +#include #include #include diff --git a/src/EnergyPlus/WindowComplexManager.hh b/src/EnergyPlus/WindowComplexManager.hh index ceb665eb72b..d8ab180c57b 100644 --- a/src/EnergyPlus/WindowComplexManager.hh +++ b/src/EnergyPlus/WindowComplexManager.hh @@ -53,6 +53,7 @@ #include // EnergyPlus Headers +#include #include #include #include diff --git a/src/EnergyPlus/WindowEquivalentLayer.hh b/src/EnergyPlus/WindowEquivalentLayer.hh index a7a72a242de..3967578d660 100644 --- a/src/EnergyPlus/WindowEquivalentLayer.hh +++ b/src/EnergyPlus/WindowEquivalentLayer.hh @@ -59,6 +59,7 @@ #include // EnergyPlus Headers +#include #include #include diff --git a/src/EnergyPlus/WindowManagerExteriorData.hh b/src/EnergyPlus/WindowManagerExteriorData.hh index 52425facca1..88d2afaeec2 100644 --- a/src/EnergyPlus/WindowManagerExteriorData.hh +++ b/src/EnergyPlus/WindowManagerExteriorData.hh @@ -54,6 +54,8 @@ #include // EnergyPlus Headers +#include +#include #include #include diff --git a/src/EnergyPlus/ZoneAirLoopEquipmentManager.hh b/src/EnergyPlus/ZoneAirLoopEquipmentManager.hh index b9e920b6f93..b07480456fb 100644 --- a/src/EnergyPlus/ZoneAirLoopEquipmentManager.hh +++ b/src/EnergyPlus/ZoneAirLoopEquipmentManager.hh @@ -52,6 +52,7 @@ #include // EnergyPlus Headers +#include #include namespace EnergyPlus { diff --git a/src/EnergyPlus/ZoneContaminantPredictorCorrector.hh b/src/EnergyPlus/ZoneContaminantPredictorCorrector.hh index c53e3c2a429..efd63642777 100644 --- a/src/EnergyPlus/ZoneContaminantPredictorCorrector.hh +++ b/src/EnergyPlus/ZoneContaminantPredictorCorrector.hh @@ -49,6 +49,7 @@ #define ZoneContaminantPredictorCorrector_hh_INCLUDED // EnergyPlus Headers +#include #include #include diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.hh b/src/EnergyPlus/ZoneTempPredictorCorrector.hh index ed05925ab1e..6f4c25c6e66 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.hh +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.hh @@ -64,7 +64,6 @@ namespace EnergyPlus { // Forward declarations - struct EnergyPlusData; class OutputFiles; // Forward declarations