Method initLoadBasedControl

src/EnergyPlus/UnitarySystem.cc:10465–10954

    }

    void UnitarySys::initLoadBasedControl(EnergyPlusData &state,
                                          int const AirLoopNum, // number of the current air loop being simulated
                                          bool const FirstHVACIteration,
                                          Real64 &OnOffAirFlowRatio,
                                          Real64 &ZoneLoad)
    {

        // SUBROUTINE INFORMATION:
        //       AUTHOR         Richard Raustad, FSEC
        //       DATE WRITTEN   February 2013

        // PURPOSE OF THIS SUBROUTINE:
        // This subroutine is for initializations of the load controlled Unitary Systems.

        // METHODOLOGY EMPLOYED:
        // Initialize mass flow rates and speed ratios. Calculate loads and adjust if necessary when using constant fan.

        // SUBROUTINE PARAMETER DEFINITIONS:
        static constexpr std::string_view routineName("InitUnitarySystems");
        Real64 QZnReq = 0.0;
        Real64 QActual = 0.0;
        Real64 SensOutputOff = 0.0;
        Real64 LatOutputOff = 0.0;
        Real64 HeatCoilLoad = 0.0;
        Real64 SupHeaterLoad = 0.0;
        HVAC::CompressorOp CompressorOn = HVAC::CompressorOp::Off;

        // do the Begin Environment initializations
        if (state.dataGlobal->BeginEnvrnFlag && this->m_MyEnvrnFlag2) {

            bool errorsFound = false;
            // set fluid-side hardware limits
            if (this->HeatCoilFluidInletNode > 0) {

                if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
                    // IF water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
                        WaterCoils::SimulateWaterCoilComponents(state, this->m_HeatingCoilName, FirstHVACIteration, this->m_HeatingCoilIndex);
                        Real64 CoilMaxVolFlowRate =
                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_HeatingCoilName, errorsFound);
                        if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                            Real64 rho = this->HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
                            this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * rho;
                        }
                    }
                    // IF steam coil max steam flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
                    if (this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
                        SteamCoils::SimulateSteamCoilComponents(state,
                                                                this->m_HeatingCoilName,
                                                                FirstHVACIteration,
                                                                this->m_HeatingCoilIndex,
                                                                1.0,
                                                                QActual); // QCoilReq, simulate any load > 0 to get max capacity
                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatingCoilIndex, errorsFound);
                        if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                            Real64 TempSteamIn = 100.0;
                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
                            this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;