From 5070ae8b7cc33978923047237e33b1c1f18721ed Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 08:49:53 -0600 Subject: [PATCH 01/12] Fix typos in docs. --- .../src/ems-actuators/hvac-systems-001.tex | 2 +- .../exterior-naturally-vented-cavity.tex | 2 +- .../coils.tex | 16 ++++++------- .../air-system-compound-component-groups.tex | 2 +- doc/essentials/src/essentials.tex | 12 +++++----- .../group-electric-load-center-generator.tex | 6 ++--- .../group-plant-condenser-control.tex | 16 ++++++------- .../overview/group-zone-forced-air-units.tex | 2 +- .../energyplus-services/error-messages.tex | 10 ++++---- .../psychrometric-services.tex | 2 +- .../hvac-network/interfacing-with-plant.tex | 12 +++++----- .../tips_and_tricks/tips_and_tricks.rst | 24 +++++++++---------- 12 files changed, 53 insertions(+), 53 deletions(-) diff --git a/doc/ems-application-guide/src/ems-actuators/hvac-systems-001.tex b/doc/ems-application-guide/src/ems-actuators/hvac-systems-001.tex index 8aab11f4052..ed6c4b13925 100644 --- a/doc/ems-application-guide/src/ems-actuators/hvac-systems-001.tex +++ b/doc/ems-application-guide/src/ems-actuators/hvac-systems-001.tex @@ -180,7 +180,7 @@ \subsection{Pump}\label{pump} \end{equation} where $P$ is the pump power (\si{\watt}), $\dot{Q}$ is the volume flow rate (\si{\volumeFlowRate}), $\eta_{total}$ is the pump total efficiency (\%) -and $\Delta P_{override}$ is your EMS-overriden pressure rise (\si{\pascal}). +and $\Delta P_{override}$ is your EMS-overridden pressure rise (\si{\pascal}). The unique identifier in both these actuator is the name of Pump Input object. diff --git a/doc/engineering-reference/src/advanced-surface-concepts/exterior-naturally-vented-cavity.tex b/doc/engineering-reference/src/advanced-surface-concepts/exterior-naturally-vented-cavity.tex index 4fa169166ec..753ecf1ca9c 100644 --- a/doc/engineering-reference/src/advanced-surface-concepts/exterior-naturally-vented-cavity.tex +++ b/doc/engineering-reference/src/advanced-surface-concepts/exterior-naturally-vented-cavity.tex @@ -237,6 +237,6 @@ \subsection{Radiation Coefficients}\label{radiation-coefficients} \subsection{References}\label{references-023} -ASHRAE HOF 2001.~ 2001 ASHRAE Fundamentals Handbook.~ American Society of Heating Refrigeration and Air-Conditioning Engineers. Altanta GA. +ASHRAE HOF 2001.~ 2001 ASHRAE Fundamentals Handbook.~ American Society of Heating Refrigeration and Air-Conditioning Engineers. Atlanta GA. ISO. 2003. ISO 15099:2003. Thermal performance of windows, doors, and shading devices -- Detailed calculations. International Organization for Standardization. diff --git a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex index 06433ea1982..4ae205972ed 100644 --- a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex +++ b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex @@ -392,7 +392,7 @@ \subsubsection{Coil Completely Wet Calculations (operating block)}\label{coil-co and \begin{equation} -OutletAirHumdityRatio = PsyWFnTdbH(OutletAirTemp,EnthAirOutlet) +OutletAirHumIdityRatio = PsyWFnTdbH(OutletAirTemp,EnthAirOutlet) \end{equation} \textbf{ELSE} @@ -2294,7 +2294,7 @@ \subsubsection{Waste heat calculation}\label{waste-heat-calculation-000} {Q_{WasteHeat}} = (Fraction)(TempModifier)(CoolingPower) \end{equation} -where Fraction is the rated waste heat fraction of the energy input and TempModifer is the waste heat modifier as a function of indoor and outdoor air dry-bulb temperature. +where Fraction is the rated waste heat fraction of the energy input and TempModifier is the waste heat modifier as a function of indoor and outdoor air dry-bulb temperature. \subsubsection{Basin Heater For Multi-Speed DX Coil}\label{basin-heater-for-multi-speed-dx-coil} @@ -2306,10 +2306,10 @@ \subsubsection{Standard Rating of Multi-Speed DX Cooling Coils}\label{standard-r ANSI/AHRI Standard 210-240 (AHRI 2017 and 2023) [AHRI 2017] For multi-speed direct expansion cooling coils, the industry standard ratings are calculated according to ANSI/AHRI Standard 210-240 (AHRI 2017). These Standard Ratings are: Standard Rating Cooling Capacity and Seasonal Energy Efficiency Ratio (SEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:MultiSpeed object. These AHRI Standard ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19,000 Watts). The equations required to calculate the net cooling capacity and SEER values according to the AHRI 2017 standard are outlined in the next two sections. Further detail can be found in the AHRI Standard 210-240 (2017) (section 11). -[AHRI 2023] Support for the 2023 version of this Standard was added in EnergyPlus version 22.2. The updated Standard Ratings are designated as: Standard Rating (Net) Cooling Capacity, Energy Efficiency Ratio (EER2), and Seasonal Energy Efficiency Ratio (SEER2). As with th 2017 version, this standard and ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19 kW). The equations used in this implementation are detailed in the AHRI standard (Section 11). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-210240-2023-2020-performance-rating-unitary-air-conditioning-air-source-heat). +[AHRI 2023] Support for the 2023 version of this Standard was added in EnergyPlus version 22.2. The updated Standard Ratings are designated as: Standard Rating (Net) Cooling Capacity, Energy Efficiency Ratio (EER2), and Seasonal Energy Efficiency Ratio (SEER2). As with the 2017 version, this standard and ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19 kW). The equations used in this implementation are detailed in the AHRI standard (Section 11). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-210240-2023-2020-performance-rating-unitary-air-conditioning-air-source-heat). ANSI/AHRI Standard 340-360 (AHRI 2022) -The Standard Rating calulations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:MultiSpeed object (see the EnergyPlus I/O Reference manual for details). According to AHRI Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capcities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are detailed in this standard (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). +The Standard Rating calculations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:MultiSpeed object (see the EnergyPlus I/O Reference manual for details). According to AHRI Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capacities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are detailed in this standard (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). Standard Ratings Reporting The values for these Standard Ratings are reported in the eplusout.eio output file and also in the predefined tabular output reports (Output:Table:SummaryReports object, '2017 Standard Ratings for DX Coils' and '2023 Standard Ratings for DX Coils'). @@ -2670,7 +2670,7 @@ \subsubsection{Standard Rating of Two-Speed DX Cooling Coils}\label{standard-rat For Two-Speed direct expansion cooling coils, the following industry standard ratings are calculated and reported according to the industry standards listed below: ANSI/AHRI Standard 340-360 (AHRI 2022) -The Standard Rating calulations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:TwoSpeed object (see the I/O Reference manual for details). According to Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capcities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are outlined in the next section. For more detail is provided in this standard itself (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). +The Standard Rating calculations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:TwoSpeed object (see the I/O Reference manual for details). According to Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capacities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are outlined in the next section. For more detail is provided in this standard itself (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). Standard Ratings Reporting The values for these Standard Ratings are reported in the eplusout.eio output file and also in the predefined tabular output reports (Output:Table:SummaryReports object, '2017 Standard Ratings for DX Coils' and '2023 Standard Ratings for DX Coils'). @@ -3134,11 +3134,11 @@ \subsubsection{Standard Rating of Variable Speed DX Cooling Coils}\label{standar For variable speed direct expansion cooling coils, the following industry standard ratings are calculated and reported according to the industry standards listed below: ANSI/AHRI Standard 210-240 (AHRI 2017 and 2023) -[AHRI 2017] The Standard Rating calulations defined in the 2017 version of this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER), Integrated Energy Efficiency Ratio (IEER), and Seasonal Energy Efficiency Ratio (SEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:MultiSpeed object. These AHRI Standard ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19,000 Watts). The equations required to calculate the net cooling capacity and SEER values aaccording to the AHRI 2017 standard are outlined below (sections 15.2.5.9 and 15.2.5.10) further detail can be found in the AHRI Standard 210-240 (2017) (section 11). -[AHRI 2023] Support for the 2023 version of this Standard was added in EnergyPlus version 22.2. The updated Standard Ratings are designated as: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER2), and Seasonal Energy Efficiency Ratio (SEER2). As with th 2017 version, this standard and ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19 kW). The equations used in this implementation are detailed in the AHRI standard (Section 11). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-210240-2023-2020-performance-rating-unitary-air-conditioning-air-source-heat). +[AHRI 2017] The Standard Rating calculations defined in the 2017 version of this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER), Integrated Energy Efficiency Ratio (IEER), and Seasonal Energy Efficiency Ratio (SEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:DX:MultiSpeed object. These AHRI Standard ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19,000 Watts). The equations required to calculate the net cooling capacity and SEER values according to the AHRI 2017 standard are outlined below (sections 15.2.5.9 and 15.2.5.10) further detail can be found in the AHRI Standard 210-240 (2017) (section 11). +[AHRI 2023] Support for the 2023 version of this Standard was added in EnergyPlus version 22.2. The updated Standard Ratings are designated as: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER2), and Seasonal Energy Efficiency Ratio (SEER2). As with the 2017 version, this standard and ratings apply only to air-to-air unitary heat pumps and air conditioners with rated cooling capacities less than 65,000 Btu/h (19 kW). The equations used in this implementation are detailed in the AHRI standard (Section 11). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-210240-2023-2020-performance-rating-unitary-air-conditioning-air-source-heat). ANSI/AHRI Standard 340-360 (AHRI 2022) -The Standard Rating calulations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:VariableSpeed object (see the EnergyPlus I/O Reference manual for details). According to AHRI Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capcities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are detailed in this standard (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). +The Standard Rating calculations defined in this standard include: Standard Rating Cooling Capacity, Energy Efficiency Ratio (EER) and Integrated Energy Efficiency Ratio (IEER). These standard ratings are calculated using the user-entered data in the Coil:Cooling:VariableSpeed object (see the EnergyPlus I/O Reference manual for details). According to AHRI Standard, these ratings apply to factory-made Commercial and Industrial Unitary Air-conditioning and Heat Pump Equipment with rated cooling/heating capacities greater than 65,000 Btu/h (19 kW) and less than 250,000 Btu/h (73.2 kW). The equations used in this implementation are detailed in this standard (Section 6). The reader can download the standard document to view these details from AHRI(https://www.ahrinet.org/search-standards/ahri-340360-i-p2022-performance-rating-commercial-and-industrial-unitary-air). Standard Ratings Reporting The values for these Standard Ratings are reported in the eplusout.eio output file and also in the predefined tabular output reports (Output:Table:SummaryReports object, '2017 Standard Ratings for DX Coils' and '2023 Standard Ratings for DX Coils'). diff --git a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex index 3d96644eeed..89969ac2832 100644 --- a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex +++ b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex @@ -207,7 +207,7 @@ \subsubsection{Load based control:}\label{load-based-control} \emph{\({\dot m_{Speed1}}\)} is the air mass flow rate through unitary system at Speed 1 (kg/s) -\(\Delta_{sen,Speed1}\) is th sensible load difference between the system output node and the zone inlet node at full-load conditions at Speed 1. +\(\Delta_{sen,Speed1}\) is the sensible load difference between the system output node and the zone inlet node at full-load conditions at Speed 1. \begin{equation} \begin{split} diff --git a/doc/essentials/src/essentials.tex b/doc/essentials/src/essentials.tex index e7fddad3dc6..b81e087da89 100644 --- a/doc/essentials/src/essentials.tex +++ b/doc/essentials/src/essentials.tex @@ -42,7 +42,7 @@ \section{What is BEM?} \begin{itemize} \item \href{https://www.ashrae.org/technical-resources/ashrae-handbook/description-2017-ashrae-handbook-fundamentals}{2017 ASHRAE Handbook - Fundamentals }Chapter 19 Energy Estimating and Modeling Methods -\item \href{https://www.bemlibrary.com/}{BEM Libary} +\item \href{https://www.bemlibrary.com/}{BEM Library} \item \href{http://www.ibpsa.org/?page_id=695}{IBPSA}, \href{https://www.ibpsa.us/videos/all}{IBPSA-USA}, and \href{https://www.youtube.com/results?search_query=building+energy+modeling}{YouTube} videos @@ -89,7 +89,7 @@ \section{Questions that BEM can answer} The most common questions that BEM can answer are: \begin{itemize} \item If my building was made or operated differently, how would the required -equpment capacity and energy consumption change? +equipment capacity and energy consumption change? \item Does my building comply with a building energy code or standard? \item What kind of rating or how many points can I get in an environmental certification program? @@ -983,7 +983,7 @@ \section{What Are All These Output Files?} \item ERR -- list of errors and warnings \item TABLE.HTML, TABLE.TXT, TABLE.TAB, TABLE.CSV, TABLE.XML -- tabulated report of the bin and monthly data in HTML, space delimited, tab delimited, -comma delimited, or XML format. This is one of the primary otuput +comma delimited, or XML format. This is one of the primary output files. \item CSV, TAB, or TXT -- time series output from the Output:Variable input object in a comma, tab, or space delimited format (generated by the @@ -1101,7 +1101,7 @@ \section{Data Sets} DataSets -- which contains IDF snippets and MacroDataSets -- which also contain IDF snippets but are in a form such that they can be easily used with the EPMacro program. Another data set are DDY files -that acompany each EPW weather file. The DDY files include several +that accompany each EPW weather file. The DDY files include several varieties of the corresponding design day data for each weather file location. @@ -1168,7 +1168,7 @@ \section{Simulation Parameters} related to the simulation that, in general, should be allowed to default. \end{itemize} For a new modeler, the following input objects may be omitted. They -can be added later for special cases althought they and appear in +can be added later for special cases although they appear in almost all of the example files: \begin{itemize} \item Timestep - the number of timesteps each hour and usually set to 6. @@ -1204,7 +1204,7 @@ \section{Location and Climate} to the full year. When debugging a file, a shorter period of time can be used to speed up the simulation portion of the Run-Check-Edit cycle. -\item RunPeriodControl:SpecialDays - allows specfication of holidays and +\item RunPeriodControl:SpecialDays - allows specification of holidays and a good example can be seen in 5ZoneCostEst.idf. \item RunPeriodControl:DaylightSavingTime - allows the specification of the start and ending period for daylight savings time. This will impact diff --git a/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex b/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex index c36ba22bab5..40192856bf8 100644 --- a/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex +++ b/doc/input-output-reference/src/overview/group-electric-load-center-generator.tex @@ -40,7 +40,7 @@ \subsubsection{Inputs}\label{inputs-014} \paragraph{Field: Transformer Usage}\label{field-transformer-usage} -This field indicates one of the three supported transformer application types: PowerInFromGrid, PowerOutToGrid, and LoadCenterPowerConditioning. A PowerInFromGrid type of transformer is used to step down voltage from the electricity grid to the building. The transformer with this type of use is somewhat free standing and does not need to be referenced in any \hyperref[electricloadcenterdistribution]{ElectricLoadCenter:Distribution} object. There should be only one PowerInFromGrid transformer in the model. A PowerOutToGrid type of transformer is used to match voltage from the building to the electricity grid. This conditions power exported out of the facility and feed back into the grid. This type of transformer will only be needed if the building ever exports power and the building and grid connection have different voltages. There should be only one PowerOutToGrid transformer in the model and it will serve all the surplus electricity produced by electric load center(s). A LoadCenterPowerConditioning type of transformer is used to match voltage between an electic load center (subpanel) and the facility's main panel. Each electric load center can have its own transformer to condition power fed into the main panel. For electric load centers that also draw power from the main panel, to charge storage, the transformer is assumed to operate in both directions (at the same performance). This type of transformer should be named in an \hyperref[electricloadcenterdistribution]{ElectricLoadCenter:Distribution} object. +This field indicates one of the three supported transformer application types: PowerInFromGrid, PowerOutToGrid, and LoadCenterPowerConditioning. A PowerInFromGrid type of transformer is used to step down voltage from the electricity grid to the building. The transformer with this type of use is somewhat free standing and does not need to be referenced in any \hyperref[electricloadcenterdistribution]{ElectricLoadCenter:Distribution} object. There should be only one PowerInFromGrid transformer in the model. A PowerOutToGrid type of transformer is used to match voltage from the building to the electricity grid. This conditions power exported out of the facility and feed back into the grid. This type of transformer will only be needed if the building ever exports power and the building and grid connection have different voltages. There should be only one PowerOutToGrid transformer in the model and it will serve all the surplus electricity produced by electric load center(s). A LoadCenterPowerConditioning type of transformer is used to match voltage between an electric load center (subpanel) and the facility's main panel. Each electric load center can have its own transformer to condition power fed into the main panel. For electric load centers that also draw power from the main panel, to charge storage, the transformer is assumed to operate in both directions (at the same performance). This type of transformer should be named in an \hyperref[electricloadcenterdistribution]{ElectricLoadCenter:Distribution} object. \paragraph{Field: Zone Name}\label{field-zone-name-005} @@ -149,7 +149,7 @@ \subsubsection{Outputs}\label{outputs-010} \item HVAC,Average,Transformer Output Electricity Rate {[}W{]} \item - HVAC,Sum,Transformer Output Elecric Energy {[}J{]} + HVAC,Sum,Transformer Output Electric Energy {[}J{]} \item HVAC,Average,Transformer Input Electricity Rate {[}W{]} \item @@ -178,7 +178,7 @@ \subsubsection{Outputs}\label{outputs-010} \paragraph{Transformer Output Electricity Rate {[}W{]}}\label{transformer-output-electric-power-w} -\paragraph{Transformer Output Elecric Energy {[}J{]}}\label{transformer-output-elecric-energy-j} +\paragraph{Transformer Output Electric Energy {[}J{]}}\label{transformer-output-electric-energy-j} These outputs are the total electricity power or energy provided by the transformer. They are equal to the metered loads which are wired to the transformer. These values are calculated for each HVAC system timestep being simulated, and the results are averaged (for power) or summed (for energy) for the timestep being reported. diff --git a/doc/input-output-reference/src/overview/group-plant-condenser-control.tex b/doc/input-output-reference/src/overview/group-plant-condenser-control.tex index bd931e9c419..ca6f9b310c3 100644 --- a/doc/input-output-reference/src/overview/group-plant-condenser-control.tex +++ b/doc/input-output-reference/src/overview/group-plant-condenser-control.tex @@ -461,9 +461,9 @@ \subsubsection{Inputs}\label{inputs-13-009} \subsection{PlantEquipmentOperation:ChillerHeaterChangeover}\label{plantequipmentoperationchillerheaterchangeover} -Plant operation can difficult to control when air-to-water or water-to-water heat pumps are used as plant equipment. Individual machines can be operated either as cooling or heat devices at any given time. This object will poll the building to determine what type of loads are dominant and determine how the plant equipment should operate. Once the mode of operation is set the apparant plant loads are dispatched to equipment listed to meet those loads. For example, a heat pump capable of providing heating or cooling will be dispatched in heating mode. It is also possible to create a heat recovery heat pump connected between the heating and cooling plant loops where this heat pump can serve low loads on one plant while supplementing the operation of the other plant. Traditional plant controls cannot meet this type of equipment configuration. This object provides a supervisory controller can be used to control one heating and one cooling hydronic plant. +Plant operation can difficult to control when air-to-water or water-to-water heat pumps are used as plant equipment. Individual machines can be operated either as cooling or heat devices at any given time. This object will poll the building to determine what type of loads are dominant and determine how the plant equipment should operate. Once the mode of operation is set the apparent plant loads are dispatched to equipment listed to meet those loads. For example, a heat pump capable of providing heating or cooling will be dispatched in heating mode. It is also possible to create a heat recovery heat pump connected between the heating and cooling plant loops where this heat pump can serve low loads on one plant while supplementing the operation of the other plant. Traditional plant controls cannot meet this type of equipment configuration. This object provides a supervisory controller can be used to control one heating and one cooling hydronic plant. -This object is used as a special plant operation scheme intended for a specific type of plant with both heating and cooling plant loops served by heat pumps which can switch between heating and cooling. EnergyPlus's usual plant operation schemes focus on one plant at a time, however the need to cleanly control heat pumps switching between heating and cooling modes requires an operation scheme that considers both the heating and cooling plant loops at the same time. This object is intended to allow controlling both heating and cooling heating plants served by heat pumps that can changeover between heating and cooling. The main focus is air source heat pumps serving seperate cooling and heating plant loops. The scheme is also able to control operation of secondary heating and cooling loops. The fullest application of this scheme include boiler backup and control of a special water to water heat pump situated to exchange heat between the return hot water and return chilled water on the secondary loops. The following diagram shows the plant configuration supported by this supervisory controller. +This object is used as a special plant operation scheme intended for a specific type of plant with both heating and cooling plant loops served by heat pumps which can switch between heating and cooling. EnergyPlus's usual plant operation schemes focus on one plant at a time, however the need to cleanly control heat pumps switching between heating and cooling modes requires an operation scheme that considers both the heating and cooling plant loops at the same time. This object is intended to allow controlling both heating and cooling heating plants served by heat pumps that can changeover between heating and cooling. The main focus is air source heat pumps serving separate cooling and heating plant loops. The scheme is also able to control operation of secondary heating and cooling loops. The fullest application of this scheme include boiler backup and control of a special water to water heat pump situated to exchange heat between the return hot water and return chilled water on the secondary loops. The following diagram shows the plant configuration supported by this supervisory controller. \begin{figure}[hbtp] \centering @@ -483,11 +483,11 @@ \subsection{PlantEquipmentOperation:ChillerHeaterChangeover}\label{plantequipmen This supervisory plant controller polls the building to see how the current loads favor operating the plants in either a cooling-only, heating-only, or simultaneous cooling and heating mode. The building loads include the predicted sensible loads to setpoint for the listed zones, the ventilation loads on any central air handlers connected to those zones, and the loads from any process loads on plant (from a LoadProfile:Plant object). The controller determines which of the three modes the plant should be in based on the polled building loads. -Once the mode of operaton is determined, the controller dispatches the equipment based on the inputs for the operation scheme and equipment lists input for that mode using the current load on the primary plant side. The heat pumps are modeled with companion objects, where a single machine has both cooling and heating input objects. The PlantEquipmentOperation:CoolingLoad operating schemes should specify equipment lists with the cooling companion models (HeatPump:PlantLoop:EIR:Cooling) and the PlantEquipmentOperation:HeatingLoad operating schemes should point to the heating companion models (HeatPump:PlantLoop:EIR:Heating). The heat pump model inputs need to set the Control Type to ``Setpoint'' control. +Once the mode of operation is determined, the controller dispatches the equipment based on the inputs for the operation scheme and equipment lists input for that mode using the current load on the primary plant side. The heat pumps are modeled with companion objects, where a single machine has both cooling and heating input objects. The PlantEquipmentOperation:CoolingLoad operating schemes should specify equipment lists with the cooling companion models (HeatPump:PlantLoop:EIR:Cooling) and the PlantEquipmentOperation:HeatingLoad operating schemes should point to the heating companion models (HeatPump:PlantLoop:EIR:Heating). The heat pump model inputs need to set the Control Type to ``Setpoint'' control. -This controller includes special handing of boiler backup. Because air-source heat pumps can be limited in their ability to operate and cold outdoor air temperatures, in is necessary to coordinate boiler operation to provide heating during cold weather. If a simple hot water boiler is present on the heating loops, it will be operated as a supplemental or auxilary heater to be used when the heat pumps cannot deliver. For example when the outdoor air is below the Low Outdoor Air Temperature limit the air source heat pumps cannot operate and a boiler is used to meeting the setpoint. Boilers found on a primary hot water loop are considered auxiliary boilers while boilers found on a secondary hot water loop are considered supplemental boilers. Auxiliary boilers, if present, are operated when the outdoor air temperature is below the Outdoor Low Temperature and use the setpoint temperature determined by outdoor air reset. The usual location of an auxiliary boiler is in the branch serving as the outlet branch on the supply side of the primary hot water loop. Supplemental boilers, if present, are operated when the inlet fluid temperature is below a setpoint. The setpoint is determined by the lower of the secondary hot water setpoint and the outdoor air reset. The usual location of a supplemental boiler is in the branch serving as the outlet branch on the supply side of the secondary hot water loop. +This controller includes special handing of boiler backup. Because air-source heat pumps can be limited in their ability to operate and cold outdoor air temperatures, in is necessary to coordinate boiler operation to provide heating during cold weather. If a simple hot water boiler is present on the heating loops, it will be operated as a supplemental or auxiliary heater to be used when the heat pumps cannot deliver. For example when the outdoor air is below the Low Outdoor Air Temperature limit the air source heat pumps cannot operate and a boiler is used to meeting the setpoint. Boilers found on a primary hot water loop are considered auxiliary boilers while boilers found on a secondary hot water loop are considered supplemental boilers. Auxiliary boilers, if present, are operated when the outdoor air temperature is below the Outdoor Low Temperature and use the setpoint temperature determined by outdoor air reset. The usual location of an auxiliary boiler is in the branch serving as the outlet branch on the supply side of the primary hot water loop. Supplemental boilers, if present, are operated when the inlet fluid temperature is below a setpoint. The setpoint is determined by the lower of the secondary hot water setpoint and the outdoor air reset. The usual location of a supplemental boiler is in the branch serving as the outlet branch on the supply side of the secondary hot water loop. -This controller includes a special handling of a dedicated water to water heat pump used to recover heat directly between the return hot water and return chlled water. The cooling and heating companions of this heat pump are named in the object. These are used to efficiently exchange heat between the return flows on the secondary hot and chilled water returns. This dedicated water to water heat pump will operate when there is sufficient flows in both returns and can be controlled to not operate when loads are high. +This controller includes a special handling of a dedicated water to water heat pump used to recover heat directly between the return hot water and return chilled water. The cooling and heating companions of this heat pump are named in the object. These are used to efficiently exchange heat between the return flows on the secondary hot and chilled water returns. This dedicated water to water heat pump will operate when there is sufficient flows in both returns and can be controlled to not operate when loads are high. \subsubsection{Inputs}\label{inputs-plantequipmentoperationchillerheaterchangeover} @@ -513,11 +513,11 @@ \subsubsection{Inputs}\label{inputs-plantequipmentoperationchillerheaterchangeov \paragraph{Field: Primary Heating Plant Setpoint at Outdoor Low Temperature}\label{field-hot-water-setpoint-reset-max-temp-diff-plantequipmentoperationchillerheaterchangeover} -This required numeric field specifies the heating plant operating set point temperature at the low outdoor air temperature. This value is generally set to the warmest temperature the heat pump can deliver at the Outdoor Low Temperature. Degress C. +This required numeric field specifies the heating plant operating set point temperature at the low outdoor air temperature. This value is generally set to the warmest temperature the heat pump can deliver at the Outdoor Low Temperature. Degrees C. \paragraph{Field: Outdoor Low Temperature}\label{field-hot-water-setpoint-reset-ratio-plantequipmentoperationchillerheaterchangeover} -This required numeric field specifies the low outdoor air temperature used for outdoor air reset and heat pump control. This serves as the lower limit for when air source heat pumps can operate in heaing mode. If the outdoor air is colder than this setting, the air source heat pumps cannot operate. Degrees C. +This required numeric field specifies the low outdoor air temperature used for outdoor air reset and heat pump control. This serves as the lower limit for when air source heat pumps can operate in heating mode. If the outdoor air is colder than this setting, the air source heat pumps cannot operate. Degrees C. \paragraph{Field: Secondary Distribution Heating Plant Setpoint Temperature}\label{secondary-distribution-heating-plant-setpoint-temperature} @@ -627,7 +627,7 @@ \subsubsection{Inputs}\label{inputs-plantequipmentoperationchillerheaterchangeov \paragraph{Supervisory Plant Auxiliary Boiler Mode}\label{operation-scheme-outputs-boiler-operation-mode} -This integer output represents the plant operating mode for the auxilary and/or supplemental boiler. Off = 0, Heating = 1. +This integer output represents the plant operating mode for the auxiliary and/or supplemental boiler. Off = 0, Heating = 1. \paragraph{Supervisory Plant Operation Polled Building Heating Load}\label{operation-scheme-outputs-supervisory-plant-operation-sensed-heating-load} diff --git a/doc/input-output-reference/src/overview/group-zone-forced-air-units.tex b/doc/input-output-reference/src/overview/group-zone-forced-air-units.tex index 43f2e9f2f5e..b10bf8baf47 100644 --- a/doc/input-output-reference/src/overview/group-zone-forced-air-units.tex +++ b/doc/input-output-reference/src/overview/group-zone-forced-air-units.tex @@ -1891,7 +1891,7 @@ \subsubsection{Inputs}\label{inputs-6-032} ZoneHVAC:OutdoorAirUnit:EquipmentList, Zone5OAUEquip1, !- Name Dehumidifier:Desiccant:NoFans, !- Component 1 Object Type - Z5Dessicant, !- Component 1 Name + Z5Desiccant, !- Component 1 Name HeatExchanger:AirToAir:FlatPlate, !- Component 2 Object Type Zone5A2AHeat Recovery, !- Component 2 Name CoilSystem:Cooling:DX, !- Component 3 Object Type diff --git a/doc/module-developer/src/energyplus-services/error-messages.tex b/doc/module-developer/src/energyplus-services/error-messages.tex index bf636074ac5..12d438b64d8 100644 --- a/doc/module-developer/src/energyplus-services/error-messages.tex +++ b/doc/module-developer/src/energyplus-services/error-messages.tex @@ -116,7 +116,7 @@ \subsection{ShowWarningError, ShowWarningMessage}\label{showwarningerror-showwar ~~ ** Warning ** Processing Monthly Tabular Reports: PEAK SPACE GAINS -The important difference between the two calls is that the ``Error'' call will incrase the ``number of warnings'' counter whereas the ``Message'' call does not incrase the counter.~ The ``Message'' call can, therefore, be used ro ``start'' off a recurring sequence without disturbing the total warning count.~ To do this, one would place the calls: +The important difference between the two calls is that the ``Error'' call will increase the ``number of warnings'' counter whereas the ``Message'' call does not increase the counter.~ The ``Message'' call can, therefore, be used to ``start'' off a recurring sequence without disturbing the total warning count.~ To do this, one would place the calls: CALL ShowWarningMessage(xxx) @@ -132,7 +132,7 @@ \subsection{ShowSevereError, ShowSevereMessage}\label{showsevereerror-showsevere ~~ ** Severe~ ** Node Connection Error, Node = ``SOFC AIR INLET NODE'', ZoneExhaust node did not find a matching inlet node. -The important difference between the two calls is that the ``Error'' call will incrase the ``number of severe errors'' counter whereas the ``Message'' call does not incrase the counter.~ The ``Message'' call can, therefore, be used ro ``start'' off a recurring sequence without disturbing the total warning count.~ To do this, one would place the calls: +The important difference between the two calls is that the ``Error'' call will increase the ``number of severe errors'' counter whereas the ``Message'' call does not increase the counter.~ The ``Message'' call can, therefore, be used to ``start'' off a recurring sequence without disturbing the total warning count.~ To do this, one would place the calls: CALL ShowSevereMessage(xxx) @@ -148,7 +148,7 @@ \subsection{ShowFatalError}\label{showfatalerror} ~~ **~ Fatal~ ** EMS user program halted simulation with error code = 9001.30 -For clarity, the sequence ending in the fatal error, should start with a Severe error and give the user a good indication of the problem.~ During execution, this Severe error may immediately preceed the Fata call. During get input, errors may be found previously in the input, interspersed with Warning errors.~ The last Severe error is stored and displayed as the program terminates. +For clarity, the sequence ending in the fatal error, should start with a Severe error and give the user a good indication of the problem.~ During execution, this Severe error may immediately precede the Fatal call. During get input, errors may be found previously in the input, interspersed with Warning errors.~ The last Severe error is stored and displayed as the program terminates. \subsection{ShowContinueError, ShowContinueErrorTimeStamp}\label{showcontinueerror-showcontinueerrortimestamp} @@ -196,7 +196,7 @@ \subsection{Recurring Error Handling}\label{recurring-error-handling} The first two parameters (Message, MsgIndex) are required.~ The remaining six arguments (ReportMaxOf, ReportMinOf, ReportSumOf, ReportMaxUnits, ReportMinUnits, ReportSumUnits) are optional. To illustrate, we re-write the above call using the recurring error routines.~ (Note that we still do the first few counted because we are using the TimeStamp routine -- however a message buffer is set up in this instance.). -!~~ Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. +!~~ Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. !~~ Wait for next time step to print warnings. If simulation iterates, print out @@ -236,7 +236,7 @@ \subsection{Recurring Error Handling}\label{recurring-error-handling} Illustrations of use of these calls is seen in the Chiller modules, PurchasedAir modules, DXCoil modules and others. -Another example is seen in the Dessicant routines: +Another example is seen in the Desiccant routines: ~ IF (Node(DesicDehum(DesicDehumNum)\%RegenAirInNode)\%MassFlowRate .NE. \& diff --git a/doc/module-developer/src/energyplus-services/psychrometric-services.tex b/doc/module-developer/src/energyplus-services/psychrometric-services.tex index 983cf5e9ee8..32523d887ad 100644 --- a/doc/module-developer/src/energyplus-services/psychrometric-services.tex +++ b/doc/module-developer/src/energyplus-services/psychrometric-services.tex @@ -90,7 +90,7 @@ \subsection{PsyRhFnTdbRhov (Tdb,Rhov,calledfrom)}\label{psyrhfntdbrhov-tdbrhovca \subsection{PsyRhFnTdbWPb (Tdb,W,Pb,calledfrom)}\label{psyrhfntdbwpb-tdbwpbcalledfrom} -Returns the relative humifity (fraction) as a function of of dry bulb temperature {[}Tdb{]} (Celsius), humidity ratio {[}W{]} (kilograms of water per kilogram of dry air) and barometric pressure {[}Pb{]} (Pascals). +Returns the relative humidity (fraction) as a function of of dry bulb temperature {[}Tdb{]} (Celsius), humidity ratio {[}W{]} (kilograms of water per kilogram of dry air) and barometric pressure {[}Pb{]} (Pascals). \subsection{PsyTwbFnTdbWPb (Tdb,W,Pb,calledfrom)}\label{psytwbfntdbwpb-tdbwpbcalledfrom} diff --git a/doc/module-developer/src/hvac-network/interfacing-with-plant.tex b/doc/module-developer/src/hvac-network/interfacing-with-plant.tex index 1d6a8481c83..ad1594f25c0 100644 --- a/doc/module-developer/src/hvac-network/interfacing-with-plant.tex +++ b/doc/module-developer/src/hvac-network/interfacing-with-plant.tex @@ -1,6 +1,6 @@ \section{Interfacing with Plant}\label{interfacing-with-plant} -Beginning with Version 7.0, EnergyPlus's plant routines were reengineered and this section discusses protocols for how component models should interact with plant loop modeling.~ Component models that reject or obtain heat from a liquid fluid stream, such as hot or chilled water, condenser water, and steam (but not refrigeration), are ``plant components'' that will need to interface with the central plant solver routines.~ This section describes a number of utility routines and concepts for developers of plant component models. +Beginning with Version 7.0, EnergyPlus's plant routines were re-engineered and this section discusses protocols for how component models should interact with plant loop modeling.~ Component models that reject or obtain heat from a liquid fluid stream, such as hot or chilled water, condenser water, and steam (but not refrigeration), are ``plant components'' that will need to interface with the central plant solver routines.~ This section describes a number of utility routines and concepts for developers of plant component models. The node structure discussed above is reused for plant.~ Each component model related to plant has inlet and outlet nodes that describe how it is connected to the loop.~ Many of the routines pass in node indexes as arguments as well as other indexes into the main plant data structure. @@ -20,7 +20,7 @@ \subsection{Plant Loop Data Structure}\label{plant-loop-data-structure} Comp is the fourth level and will be sized to the total number of components on the branch. -There are four indices that indentify each component's location for each of the plant loops it is connected with: : loop number, loop side number, branch number, and component number.~ A water cooled chiller will be connected to two loops and so the component itself will appear twice in the data structure and one set of indices will identify its location on the chilled water loop while a second set of indices will locate it on the condenser loop.~~ +There are four indices that identify each component's location for each of the plant loops it is connected with: : loop number, loop side number, branch number, and component number.~ A water cooled chiller will be connected to two loops and so the component itself will appear twice in the data structure and one set of indices will identify its location on the chilled water loop while a second set of indices will locate it on the condenser loop.~~ \subsection{Initialization}\label{initialization} @@ -38,9 +38,9 @@ \subsection{Sizing}\label{sizing} \begin{itemize} \item - PlantFirstSizesOkayToFinalizePlantSizeNotComplete This public logical boolean flag is declared in DataPlant. It starts out FALSE TRUEfalse and is set to TRUE FALSEtrue only after all some intial plant sizing actions iterations have been completed and the first set of sizes can be finalized. Component models should delay first filling autosized values until this flag is true. The -9999 values that indicate an autosized variable are not filled until this is TRUE. + PlantFirstSizesOkayToFinalizePlantSizeNotComplete This public logical boolean flag is declared in DataPlant. It starts out FALSE TRUEfalse and is set to TRUE FALSEtrue only after all some initial plant sizing actions iterations have been completed and the first set of sizes can be finalized. Component models should delay first filling autosized values until this flag is true. The -9999 values that indicate an autosized variable are not filled until this is TRUE. \item - PlantFirstSizesOkayToReportPlantSizesOkayToFinalize This public logical boolean flag is declared in DataPlant. It starts out false FALSE and is set to TRUE true after the main iterative phase of sizing is completed but before the final finishing passes are made. This flag is only used for advanced sizing methods based on HVAC Sizing Simulations, where the program should report both the ``Initial'' sizes and the final sizes. Component models should delay final reporting first sizes and filling of autosized values until this is set to TRUEtrue. The -9999 values that indicate an autosized variable are not filled until this is TRUE. The first, or intial, cCalls to report the outcome of sizing are not made until this is TRUEtrue. + PlantFirstSizesOkayToReportPlantSizesOkayToFinalize This public logical boolean flag is declared in DataPlant. It starts out false FALSE and is set to TRUE true after the main iterative phase of sizing is completed but before the final finishing passes are made. This flag is only used for advanced sizing methods based on HVAC Sizing Simulations, where the program should report both the ``Initial'' sizes and the final sizes. Component models should delay final reporting first sizes and filling of autosized values until this is set to TRUEtrue. The -9999 values that indicate an autosized variable are not filled until this is TRUE. The first, or initial, cCalls to report the outcome of sizing are not made until this is TRUEtrue. \item PlantFinalSizesOkayToReport This public boolean flag is declared in DataPlant. It starts out false and is set to true when all the sizing is done and it is okay to report the final size values. Component models should delay reporting final sizes until this is set to true. \item @@ -67,7 +67,7 @@ \subsection{Sizing}\label{sizing} 6.~~~~Sizing finished and PlantSizeNotCompleteset FALSE -In earlier versions, component sizing routines were only called once and one had to take care not call them repeatedly (or else their flow request would get doubled each time). However, now plant component models should be designed for multiple executions of their component-level sizing routine. This allows for an iterative approach to plant sizing that is used to solve complex problems raised by inter-connected loops and the interdependence of sizing information. As of version 8.3, the addition of HVAC Sizing Simulation method makes it very explicit that not only do sizing routines need to be able to rerun, the autosized values need to be set to useable values and then changed. It is therefore now necessary to store whether or not the original input was set to autosize and so autosizable input now needs to add a boolean ``*WasAutoSized'' version of the variable to keep track of the user input. +In earlier versions, component sizing routines were only called once and one had to take care not call them repeatedly (or else their flow request would get doubled each time). However, now plant component models should be designed for multiple executions of their component-level sizing routine. This allows for an iterative approach to plant sizing that is used to solve complex problems raised by inter-connected loops and the interdependence of sizing information. As of version 8.3, the addition of HVAC Sizing Simulation method makes it very explicit that not only do sizing routines need to be able to rerun, the autosized values need to be set to usable values and then changed. It is therefore now necessary to store whether or not the original input was set to autosize and so autosizable input now needs to add a boolean ``*WasAutoSized'' version of the variable to keep track of the user input. After the component model has determined a design value for the flow rate, this flow rate needs to be registered with the larger plant routines by calling RegisterPlantCompDesignFlow.~This is a volume flow rate in m\(^{3}\)/s.~ The flow rate is associated with the inlet node.~ This call can be repeated and the design flow will be updated with the latest request. @@ -113,7 +113,7 @@ \subsection{Central Routine Modifications}\label{central-routine-modifications} d.~~~Array ValidLoopEquipTypes.~ Add array element with classification for what type of loop this component is intended for, primarily with respect to the type of loop it is intended to meet loads. -e.~~~~Parameter TypeOf\_xxxx .~ Add an integer parameter to identify ``TypeOf'' number for subsequent use to identify component type without having to do string comparisions. +e.~~~~Parameter TypeOf\_xxxx .~ Add an integer parameter to identify ``TypeOf'' number for subsequent use to identify component type without having to do string comparisons. 2.~~~~PlantManager.f90 diff --git a/doc/readthedocs/sphinx/tips_and_tricks/tips_and_tricks.rst b/doc/readthedocs/sphinx/tips_and_tricks/tips_and_tricks.rst index 76b1ceb5047..275132fb09d 100644 --- a/doc/readthedocs/sphinx/tips_and_tricks/tips_and_tricks.rst +++ b/doc/readthedocs/sphinx/tips_and_tricks/tips_and_tricks.rst @@ -43,7 +43,7 @@ https://energyplushelp.freshdesk.com/ The site is monitored by EnergyPlus developers and questions are attempted to be answered in a timely manner. Standard EnergyPlus support -is provided free of charge by the U.S. Deparment of Energy, as part of a +is provided free of charge by the U.S. Department of Energy, as part of a continuing effort to improve the EnergyPlus building simulation tool. Expedited, priority support may be available from other sources. The helpdesk has a files area where important (after release) files may be @@ -133,7 +133,7 @@ Datasets aka Libraries ---------------------- EnergyPlus uses the term DataSets for what many would call libraries. -These files are included, for the most part, in the instalation package +These files are included, for the most part, in the installation package but may be available from other sites (such as the helpdesk or Yahoo Groups). @@ -141,7 +141,7 @@ There are two flavors of DataSets: **simple** and **Macro**. Some sets have files in both camps (for example, Solar Collectors). Both flavors contain IDF objects ready to be put into EnergyPlus input files. With the simple datasets, you may need to use a text editor or the IDF Editor -to search the file for the one you want to use. With the macro datsets +to search the file for the one you want to use. With the macro datasets and a simply structured imf (input macro file), you can name the item you want to include. (The macro program is described in the `Auxiliary Programs document `__). @@ -291,7 +291,7 @@ You can’t measure extraterrestrial unless you’re in outer space, but then it’s assumed to be constant anyway. For the various radiation and illuminance values, they can measured by various instrumentation ranging from the very cheap to the very expensive. Properly, radiation needs to -be measured with a pyranometer (Eppley), which is pricy, but I’m also +be measured with a pyranometer (Eppley), which is pricey, but I’m also seen people use simpler apparatus (Lycors) that are really photometers. Direct beam is generally not measured, but derived by subtracting the diffuse from the global. Diffuse is measured by adding a shadow band @@ -1024,7 +1024,7 @@ each other: and diffuse solar (and daylighting) to pass between the adjacent zones. -* Radiant (long-wave thermal) transfer can be signifcant between exterior surfaces of a perimeter zone and +* Radiant (long-wave thermal) transfer can be significant between exterior surfaces of a perimeter zone and interior surfaces of a core zone with an open boundary between them. Normally, there is no direct radiant exchange between surfaces in different thermal zones. Construction:AirBoundary groups adjacent @@ -1133,7 +1133,7 @@ The Trombe wall convection algorithm is applicable to just about any vertical cavity with a high aspect ratio and relatively narrow width. I’m not sure if a double facade cavity would meet the aspect ratio requirement. But I do know the Trombe wall algorithm is not picky about -whether the inner wall is highly absorbant, or about any particular +whether the inner wall is highly absorbent, or about any particular properties of the walls. Actually the same basic algorithm is used by the window model to calculate the convection between the two panes of a window. The full reference is ISO 15099. @@ -1254,7 +1254,7 @@ that are used during EnergyPlus development testing (i.e.small differences are within .001 or .5%; big differences are greater than those limits). -For the purposes of dicussion, the buildings will be called: +For the purposes of discussion, the buildings will be called: * Multistory 1 – the original 9 zone building (with multipliers and groups) ref: Figure `fig:original-multistory-idf`_; * Multistory 2 – the building shown in Figure `fig:multistory-with-cloned-middle-zones`_. @@ -1317,7 +1317,7 @@ With these included, the files were rerun with the following results: .. table:: Multiplier Results with negated height variation. +---------------+---------------------+---------------------+---------------------+---------------------+ - | Location | Multi-story 2 Loahs | Multi-story 2 Meter | Multi-story 3 Loahs | Multi-story 3 Meter | + | Location | Multi-story 2 Loads | Multi-story 2 Meter | Multi-story 3 Loads | Multi-story 3 Meter | +===============+=====================+=====================+=====================+=====================+ | Chicago | Small diffs | Small diffs | Small diffs | Small diffs | +---------------+---------------------+---------------------+---------------------+---------------------+ @@ -1796,7 +1796,7 @@ A coil will check its inlet air temperature compared to the set point temperature. For cooling, if the inlet air temperature is above the set point temp, the coil turns on. It’s opposite that for heating. In the 5ZoneAutoDXVAV example file, a schedule temperature set point is placed -at the system outlet node. This is the temperture the designer wants at +at the system outlet node. This is the temperature the designer wants at the outlet. The mixed air SP manager is used to account for fan heat and places the required SP at the outlet of the cooling coil so the coil slightly overcools the air to overcome fan heat and meet the system @@ -1828,7 +1828,7 @@ SetpointManager objects place a setpoint on a node, for example, one might place a setpoint of 12C on the node named “Main Cooling Coil Air Outlet Node”. -In the case of Controler:WaterCoil which controls a hot water or chilled +In the case of Controller:WaterCoil which controls a hot water or chilled water coil, the controller reads the setpoint and tries to adjust the water flow so that the air temperature at the controlled node matches the current setpoint. Continuing the example above: @@ -2500,7 +2500,7 @@ Low Temperature Radiant Undersizing Issues ------------------------------------------ Some users have noted difficulties when trying to size certain aspects -of low temperature radiant systems, particulary in cooling mode for the +of low temperature radiant systems, particularly in cooling mode for the hydronic (variable flow) and constant flow low temperature radiant systems when using autosize. The problem appears to be that the system is not sizing properly or is undersizing, leaving zone conditions that @@ -3799,7 +3799,7 @@ buildings with large numbers of surfaces and shading surfaces): .. table:: Recommended Reduce Time Settings for Early Diagnostic runs ======================= ================================================================================ - Object Recommenheh Early Diagnostic Setting + Object Recommended Early Diagnostic Setting Building MinimalShadowing (Solar Distribution field) ShadowCalculation 200 (Maximum Figures in Shadow Overlap Calculations field) SizingPeriod:DesignDays Only perform design day or limited run period runs until you have the model set. From 3aefa292a0f5cd47990131432cfeb284f27f2b69 Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 08:50:14 -0600 Subject: [PATCH 02/12] Fix typos in idd. --- idd/Energy+.idd.in | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/idd/Energy+.idd.in b/idd/Energy+.idd.in index fa0cf2f26d9..9e7990db444 100644 --- a/idd/Energy+.idd.in +++ b/idd/Energy+.idd.in @@ -22827,7 +22827,7 @@ IndoorLivingWall, \object-list ScheduleNames \note units in Schedule should be fraction applied to design level of other equipment, generally (0.0 - 1.0) A4 , \field Evapotranspiration Calculation Method - \note Model selection for caclulating evapotranspiration of indoor greenery system. + \note Model selection for calculating evapotranspiration of indoor greenery system. \note This rate can also be actuated with user-defined calculations, see EMS application guide for actuator details. \type choice \key Penman-Monteith @@ -22844,8 +22844,8 @@ IndoorLivingWall, \object-list ScheduleNames A7 , \field Daylighting Control Name \note If daylighting is used in the selected lighting methods (Daylight or LED-Daylight), - \note users should define an object of Daylighting:Control to obtain the daylighting illumance level - \note and an object for Daylighing:ReferencePoint for the daylighting sensor location in the thermal zone. + \note users should define an object of Daylighting:Control to obtain the daylighting illuminance level + \note and an object for Daylighting:ReferencePoint for the daylighting sensor location in the thermal zone. \note The name of the object of Daylighting:Controls should be specified in this field. \type alpha A8 , \field LED-Daylight Targeted Lighting Intensity Schedule Name @@ -63068,7 +63068,7 @@ HeatExchanger:AirToAir:SensibleAndLatent, \note when the economizer is operating or high humidity control is active A11,\field Sensible Effectiveness of Heating Air Flow Curve Name \note optional - \note if this field has value, then the sensivle effectiveness for heating + \note if this field has value, then the sensible effectiveness for heating \note will be the value in N2 multiplied by this curve value \type object-list \object-list UnivariateFunctions @@ -63080,7 +63080,7 @@ HeatExchanger:AirToAir:SensibleAndLatent, \object-list UnivariateFunctions A13,\field Sensible Effectiveness of Cooling Air Flow Curve Name \note optional - \note if this field has value, then the sensivle effectiveness for cooling + \note if this field has value, then the sensible effectiveness for cooling \note will be the value in N4 multiplied by this curve value \type object-list \object-list UnivariateFunctions @@ -73688,7 +73688,7 @@ Chiller:Electric:EIR, \minimum 0.0 \default 0.0 \note Thermosiphon model is disabled below this minimum limit and - \note when the load is greater than calculated using the prevoius field. + \note when the load is greater than calculated using the previous field. Chiller:Electric:ReformulatedEIR, \min-fields 22 @@ -73936,7 +73936,7 @@ Chiller:Electric:ReformulatedEIR, \minimum 0.0 \default 0.0 \note Thermosiphon model is disabled below this minimum limit and - \note when the load is greater than calculated using the prevoius field. + \note when the load is greater than calculated using the previous field. Chiller:Electric, \min-fields 27 @@ -74097,7 +74097,7 @@ Chiller:Electric, \minimum 0.0 \default 0.0 \note Thermosiphon model is disabled below this minimum limit and - \note when the load is greater than calculated using the prevoius field. + \note when the load is greater than calculated using the previous field. Chiller:Absorption:Indirect, \min-fields 17 @@ -74487,7 +74487,7 @@ Chiller:ConstantCOP, \minimum 0.0 \default 0.0 \note Thermosiphon model is disabled below this minimum limit and - \note when the load is greater than calculated using the prevoius field. + \note when the load is greater than calculated using the previous field. Chiller:EngineDriven, \min-fields 43 @@ -75454,7 +75454,7 @@ HeatPump:PlantLoop:EIR:Cooling, \minimum 0.0 \default 0.0 \note Thermosiphon model is disabled below this minimum limit and - \note when the load is greater than calculated using the prevoius field. + \note when the load is greater than calculated using the previous field. HeatPump:PlantLoop:EIR:Heating, From 5c6ac382728058c187e5ae17d9d6b18f38c4367f Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 08:50:53 -0600 Subject: [PATCH 03/12] Fix typos in src. --- src/EnergyPlus/AirLoopHVACDOAS.cc | 2 +- src/EnergyPlus/BaseboardRadiator.cc | 8 +- src/EnergyPlus/BranchInputManager.cc | 4 +- src/EnergyPlus/ChilledCeilingPanelSimple.cc | 4 +- src/EnergyPlus/ChillerAbsorption.cc | 6 +- src/EnergyPlus/ChillerExhaustAbsorption.cc | 22 ++-- src/EnergyPlus/ChillerIndirectAbsorption.cc | 2 +- .../Coils/CoilCoolingDXCurveFitPerformance.cc | 2 +- src/EnergyPlus/CondenserLoopTowers.cc | 30 ++--- src/EnergyPlus/DXCoils.cc | 106 +++++++++--------- src/EnergyPlus/EcoRoofManager.cc | 18 +-- src/EnergyPlus/EconomicTariff.cc | 40 +++---- src/EnergyPlus/ElectricBaseboardRadiator.cc | 4 +- src/EnergyPlus/EvaporativeCoolers.cc | 50 ++++----- src/EnergyPlus/EvaporativeFluidCoolers.cc | 12 +- src/EnergyPlus/FluidCoolers.cc | 4 +- src/EnergyPlus/Furnaces.cc | 48 ++++---- src/EnergyPlus/General.cc | 10 +- src/EnergyPlus/GeneratorDynamicsManager.cc | 6 +- src/EnergyPlus/GeneratorFuelSupply.cc | 2 +- .../FiniteDifferenceGroundTemperatureModel.cc | 16 +-- src/EnergyPlus/HVACMultiSpeedHeatPump.cc | 30 ++--- src/EnergyPlus/HVACSingleDuctInduc.cc | 6 +- src/EnergyPlus/HWBaseboardRadiator.cc | 12 +- src/EnergyPlus/HeatBalanceSurfaceManager.cc | 48 ++++---- src/EnergyPlus/HeatPumpWaterToWaterSimple.cc | 6 +- src/EnergyPlus/HeatRecovery.cc | 38 +++---- src/EnergyPlus/HighTempRadiantSystem.cc | 4 +- src/EnergyPlus/HybridEvapCoolingModel.cc | 62 +++++----- src/EnergyPlus/HybridModel.cc | 28 ++--- .../HybridUnitaryAirConditioners.cc | 32 +++--- src/EnergyPlus/InternalHeatGains.cc | 8 +- src/EnergyPlus/LowTempRadiantSystem.cc | 22 ++-- src/EnergyPlus/MicroCHPElectricGenerator.cc | 12 +- .../MicroturbineElectricGenerator.cc | 2 +- src/EnergyPlus/OutputReportTabular.cc | 62 +++++----- src/EnergyPlus/Photovoltaics.cc | 22 ++-- src/EnergyPlus/Plant/PlantManager.cc | 20 ++-- src/EnergyPlus/PlantChillers.cc | 12 +- src/EnergyPlus/PlantPressureSystem.cc | 4 +- src/EnergyPlus/PurchasedAirManager.cc | 32 +++--- src/EnergyPlus/RefrigeratedCase.cc | 64 +++++------ src/EnergyPlus/SZVAVModel.cc | 10 +- src/EnergyPlus/ScheduleManager.cc | 6 +- src/EnergyPlus/SimulationManager.cc | 4 +- src/EnergyPlus/SimulationManager.hh | 2 +- src/EnergyPlus/SizingAnalysisObjects.cc | 4 +- src/EnergyPlus/SizingManager.cc | 30 ++--- src/EnergyPlus/SolarCollectors.cc | 18 +-- src/EnergyPlus/SolarShading.cc | 52 ++++----- src/EnergyPlus/StandardRatings.cc | 56 ++++----- src/EnergyPlus/SteamBaseboardRadiator.cc | 14 +-- src/EnergyPlus/SurfaceGeometry.cc | 32 +++--- src/EnergyPlus/TARCOGArgs.cc | 4 +- src/EnergyPlus/TARCOGMain.cc | 46 ++++---- src/EnergyPlus/TarcogShading.cc | 38 +++---- src/EnergyPlus/ThermalComfort.cc | 8 +- src/EnergyPlus/ThermalISO15099Calc.cc | 22 ++-- src/EnergyPlus/TranspiredCollector.cc | 22 ++-- src/EnergyPlus/UnitarySystem.cc | 24 ++-- src/EnergyPlus/VariableSpeedCoils.cc | 4 +- src/EnergyPlus/WaterCoils.cc | 8 +- src/EnergyPlus/WindTurbine.cc | 6 +- src/EnergyPlus/WindowEquivalentLayer.cc | 96 ++++++++-------- src/EnergyPlus/WindowManager.cc | 48 ++++---- .../WindowManagerExteriorThermal.cc | 2 +- src/EnergyPlus/ZoneEquipmentManager.cc | 2 +- src/EnergyPlus/ZoneTempPredictorCorrector.cc | 22 ++-- 68 files changed, 751 insertions(+), 751 deletions(-) diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc index b382733e760..3c87f87a536 100644 --- a/src/EnergyPlus/AirLoopHVACDOAS.cc +++ b/src/EnergyPlus/AirLoopHVACDOAS.cc @@ -789,7 +789,7 @@ namespace AirLoopHVACDOAS { thisDOAS.m_CompPointerAirLoopSplitter = thisAirLoopSplitter.factory(state, thisDOAS.m_AirLoopSplitterIndex, thisDOAS.AirLoopSplitterName); - // get pretreated desing conditions + // get pretreated design conditions thisDOAS.PreheatTemp = fields.at("preheat_design_temperature").get(); thisDOAS.PreheatHumRat = fields.at("preheat_design_humidity_ratio").get(); thisDOAS.PrecoolTemp = fields.at("precool_design_temperature").get(); diff --git a/src/EnergyPlus/BaseboardRadiator.cc b/src/EnergyPlus/BaseboardRadiator.cc index 7f03f312eaf..2c37fed129d 100644 --- a/src/EnergyPlus/BaseboardRadiator.cc +++ b/src/EnergyPlus/BaseboardRadiator.cc @@ -611,9 +611,9 @@ namespace BaseboardRadiator { bool ErrorsFound(false); // If errors detected in input Real64 rho; // local fluid density Real64 Cp; // local fluid specific heat - Real64 WaterVolFlowRateMaxDes(0.0); // Design water volume flow for reproting + Real64 WaterVolFlowRateMaxDes(0.0); // Design water volume flow for reporting Real64 WaterVolFlowRateMaxUser(0.0); // User hard-sized volume flow for reporting - Real64 UADes(0.0); // Design UA value for reproting + Real64 UADes(0.0); // Design UA value for reporting Real64 UAUser(0.0); // User hard-sized value for reporting Real64 TempSize; // autosized value of coil input field @@ -736,7 +736,7 @@ namespace BaseboardRadiator { // UA sizing bool UAAutoSize = false; // Indicator to autosizing UA - // Set hard-sized values to the local variable to correct a false indication aftet SolFla function calculation + // Set hard-sized values to the local variable to correct a false indication after SolFla function calculation if (this->UA == DataSizing::AutoSize) { UAAutoSize = true; } else { @@ -922,7 +922,7 @@ namespace BaseboardRadiator { } } } else { - // if there is no heating Sizing:Plant object and autosizng was requested, issue an error message + // if there is no heating Sizing:Plant object and autosizing was requested, issue an error message if (this->WaterVolFlowRateMax == DataSizing::AutoSize || this->UA == DataSizing::AutoSize) { ShowSevereError(state, format("SizeBaseboard: {}=\"{}\"", cCMO_BBRadiator_Water, this->EquipID)); ShowContinueError(state, "...Autosizing of hot water baseboard requires a heating loop Sizing:Plant object"); diff --git a/src/EnergyPlus/BranchInputManager.cc b/src/EnergyPlus/BranchInputManager.cc index 4e7c1508110..aa90b28e25b 100644 --- a/src/EnergyPlus/BranchInputManager.cc +++ b/src/EnergyPlus/BranchInputManager.cc @@ -1322,7 +1322,7 @@ namespace BranchInputManager { } else { state.dataBranchInputManager->BranchList(BCount).BranchNames({1, NumAlphas - 1}) = Alphas({2, NumAlphas}); for (Loop = 1; Loop <= state.dataBranchInputManager->BranchList(BCount).NumOfBranchNames; ++Loop) { - // If NumOfBranches = 0 then Branches havent been read yet. + // If NumOfBranches = 0 then Branches haven't been read yet. if ((int)state.dataBranchInputManager->Branch.size() == 0) { GetBranchInput(state); } @@ -2251,7 +2251,7 @@ namespace BranchInputManager { // DATE WRITTEN February 2008 // PURPOSE OF THIS SUBROUTINE: - // An auxiliary routine locate a Airenser loop and type from a BranchListName + // An auxiliary routine to locate a Air condenser loop and type from a BranchListName // METHODOLOGY EMPLOYED: // calls GetObject for PRIMARY AIR LOOP diff --git a/src/EnergyPlus/ChilledCeilingPanelSimple.cc b/src/EnergyPlus/ChilledCeilingPanelSimple.cc index 811b5aead15..07502f83899 100644 --- a/src/EnergyPlus/ChilledCeilingPanelSimple.cc +++ b/src/EnergyPlus/ChilledCeilingPanelSimple.cc @@ -783,7 +783,7 @@ void InitCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum, int cons // This subroutine initializes the cooling panel units, and determines the UA values during simulation. // METHODOLOGY EMPLOYED: - // The initialization subrotines borrowed from other sources and heat exchanger formulation for cooling panel. + // The initialization subroutines borrowed from other sources and heat exchanger formulation for cooling panel. // REFERENCES: // Incropera and DeWitt, Fundamentals of Heat and Mass Transfer @@ -1568,7 +1568,7 @@ void DistributeCoolingPanelRadGains(EnergyPlusData &state) // DATE WRITTEN Sept 2014 // PURPOSE OF THIS SUBROUTINE: - // To distribute the gains from the hot water basebaord heater + // To distribute the gains from the hot water baseboard heater // as specified in the user input file. This includes distribution // of long wavelength radiant gains to surfaces and "people." diff --git a/src/EnergyPlus/ChillerAbsorption.cc b/src/EnergyPlus/ChillerAbsorption.cc index 879e1725eda..43643677124 100644 --- a/src/EnergyPlus/ChillerAbsorption.cc +++ b/src/EnergyPlus/ChillerAbsorption.cc @@ -1222,7 +1222,7 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) BaseSizer::reportSizerOutput(state, moduleObjectType, this->Name, - "Iniital Design Size Design Generator Fluid Flow Rate [m3/s]", + "Initial Design Size Design Generator Fluid Flow Rate [m3/s]", tmpGeneratorVolFlowRate); } } else { @@ -1512,7 +1512,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R // limit by max capacity this->QEvaporator = min(this->QEvaporator, (this->MaxPartLoadRat * this->NomCap)); - // Either set the flow to the Constant value or caluclate the flow for the variable volume + // Either set the flow to the Constant value or calculate the flow for the variable volume if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { this->EvapMassFlowRate = state.dataLoopNodes->Node(this->EvapInletNodeNum).MassFlowRate; @@ -1746,7 +1746,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { GenMassFlowRate = this->GenMassFlowRateMax; } else { // LeavingSetpointModulated - // since the .FlowMode applies to the chiller evaporator, the generater mass flow rate will be proportional to the evaporator + // since the .FlowMode applies to the chiller evaporator, the generator mass flow rate will be proportional to the evaporator // mass flow rate Real64 GenFlowRatio = this->EvapMassFlowRate / this->EvapMassFlowRateMax; GenMassFlowRate = min(this->GenMassFlowRateMax, GenFlowRatio * this->GenMassFlowRateMax); diff --git a/src/EnergyPlus/ChillerExhaustAbsorption.cc b/src/EnergyPlus/ChillerExhaustAbsorption.cc index bdf19121c02..acd74c9cd8a 100644 --- a/src/EnergyPlus/ChillerExhaustAbsorption.cc +++ b/src/EnergyPlus/ChillerExhaustAbsorption.cc @@ -86,7 +86,7 @@ namespace EnergyPlus::ChillerExhaustAbsorption { // for Gas Research Institute (Original module GasAbsoptionChiller) // DATE WRITTEN March 2001 // MODIFIED Brent Griffith, Nov 2010 plant upgrades, generalize fluid properties -// Mahabir Bhandari, ORNL, Aug 2011, modified to accomodate Exhaust Fired Absorption Chiller +// Mahabir Bhandari, ORNL, Aug 2011, modified to accommodate Exhaust Fired Absorption Chiller // PURPOSE OF THIS MODULE: // This module simulates the performance of the Exhaust fired double effect @@ -238,7 +238,7 @@ void ExhaustAbsorberSpecs::getDesignCapacities( if (!matchfound) { // Error, nodes do not match - ShowSevereError(state, format("SimExhaustAbsorber: Invalid call to Exhaust Absorbtion Chiller-Heater {}", this->Name)); + ShowSevereError(state, format("SimExhaustAbsorber: Invalid call to Exhaust Absorption Chiller-Heater {}", this->Name)); ShowContinueError(state, "Node connections in branch are not consistent with object nodes."); ShowFatalError(state, "Preceding conditions cause termination."); } // Operate as Chiller or Heater @@ -442,7 +442,7 @@ void GetExhaustAbsorberInput(EnergyPlusData &state) ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError(state, "resetting to ENTERING-CONDENSER, simulation continues"); } - // Assign Other Paramters + // Assign Other Parameters if (Util::SameString(state.dataIPShortCut->cAlphaArgs(16), "AirCooled")) { thisChiller.isWaterCooled = false; } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(16), "WaterCooled")) { @@ -937,7 +937,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 rho; // local fluid density - Real64 mdot; // lcoal fluid mass flow rate + Real64 mdot; // local fluid mass flow rate int CondInletNode = this->CondReturnNodeNum; int CondOutletNode = this->CondSupplyNodeNum; @@ -1448,7 +1448,7 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) // SUBROUTINE INFORMATION: // AUTHOR Jason Glazer // DATE WRITTEN March 2001 - // MODIFIED Mahabir Bhandari, ORNL, Aug 2011, modified to accomodate exhaust fired chiller + // MODIFIED Mahabir Bhandari, ORNL, Aug 2011, modified to accommodate exhaust fired chiller // PURPOSE OF THIS SUBROUTINE: // Simulate a Exhaust fired (Exhaust consuming) absorption chiller using @@ -1515,7 +1515,7 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) int lThermalEnergyCoolFPLRCurve = this->ThermalEnergyCoolFPLRCurve; int lElecCoolFTCurve = this->ElecCoolFTCurve; int lElecCoolFPLRCurve = this->ElecCoolFPLRCurve; - bool lIsEnterCondensTemp = this->isEnterCondensTemp; // if using entering conderser water temperature is TRUE, exiting is FALSE + bool lIsEnterCondensTemp = this->isEnterCondensTemp; // if using entering condenser water temperature is TRUE, exiting is FALSE bool lIsWaterCooled = this->isWaterCooled; // if water cooled it is TRUE Real64 lCHWLowLimitTemp = this->CHWLowLimitTemp; Real64 lHeatElectricPower = this->HeatElectricPower; // parasitic electric power used for heating @@ -1722,7 +1722,7 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) Curve::CurveValue(state, lElecCoolFTCurve, lChillSupplyTemp, calcCondTemp) * Curve::CurveValue(state, lElecCoolFPLRCurve, lCoolPartLoadRatio); - // determine conderser load which is cooling load plus the + // determine condenser load which is cooling load plus the // ThermalEnergy used for cooling plus // the electricity used lTowerLoad = lCoolingLoad + lCoolThermalEnergyUseRate / lThermalEnergyHeatRatio + lCoolElectricPower; @@ -1754,7 +1754,7 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) this->ExhTempLTAbsLeavingTempIndex, lExhaustInTemp, AbsLeavingTemp); - // If exhaust is not available, it means the avilable thermal energy is 0.0 and Chiller is not available + // If exhaust is not available, it means the available thermal energy is 0.0 and Chiller is not available lCoolThermalEnergyUseRate = 0.0; lTowerLoad = 0.0; lCoolElectricPower = 0.0; @@ -1835,7 +1835,7 @@ void ExhaustAbsorberSpecs::calcHeater(EnergyPlusData &state, Real64 &MyLoad, boo // SUBROUTINE INFORMATION: // AUTHOR Jason Glazer and Michael J. Witte // DATE WRITTEN March 2001 - // MODIFIED Mahabir Bhandari, ORNL, Aug 2011, modified to accomodate exhaust fired double effect absorption chiller + // MODIFIED Mahabir Bhandari, ORNL, Aug 2011, modified to accommodate exhaust fired double effect absorption chiller // PURPOSE OF THIS SUBROUTINE: // Simulate a Exhaust fired (Exhaust consuming) absorption chiller using @@ -1967,7 +1967,7 @@ void ExhaustAbsorberSpecs::calcHeater(EnergyPlusData &state, Real64 &MyLoad, boo // Calculate electric parasitics used // for heating based on nominal capacity not available capacity lHeatElectricPower = this->NomCoolingCap * this->NomHeatCoolRatio * this->ElecHeatRatio * lFractionOfPeriodRunning; - // Coodinate electric parasitics for heating and cooling to avoid double counting + // Coordinate electric parasitics for heating and cooling to avoid double counting // Total electric is the max of heating electric or cooling electric // If heating electric is greater, leave cooling electric and subtract if off of heating elec // If cooling electric is greater, set heating electric to zero @@ -1997,7 +1997,7 @@ void ExhaustAbsorberSpecs::calcHeater(EnergyPlusData &state, Real64 &MyLoad, boo this->ExhTempLTAbsLeavingHeatingTempIndex, lExhaustInTemp, AbsLeavingTemp); - // If exhaust is not available, it means the avilable thermal energy is 0.0 and Chiller is not available + // If exhaust is not available, it means the available thermal energy is 0.0 and Chiller is not available lHeatThermalEnergyUseRate = 0.0; lHeatElectricPower = 0.0; lHotWaterSupplyTemp = heatReturnNode.Temp; diff --git a/src/EnergyPlus/ChillerIndirectAbsorption.cc b/src/EnergyPlus/ChillerIndirectAbsorption.cc index 9a60e43c688..ca2c36ea85c 100644 --- a/src/EnergyPlus/ChillerIndirectAbsorption.cc +++ b/src/EnergyPlus/ChillerIndirectAbsorption.cc @@ -1768,7 +1768,7 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 const MyLoad this->PossibleSubcooling = false; this->QEvaporator = std::abs(MyLoad); - // Either set the flow to the Constant value or caluclate the flow for the variable volume + // Either set the flow to the Constant value or calculate the flow for the variable volume if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { this->EvapMassFlowRate = state.dataLoopNodes->Node(this->EvapInletNodeNum).MassFlowRate; diff --git a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc index 67ab205d590..5658d94ff24 100644 --- a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc +++ b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc @@ -447,7 +447,7 @@ void CoilCoolingDXCurveFitPerformance::calcStandardRatings210240(EnergyPlus::Ene Real64 ElecPowerReducedCap(0.0); // Net power consumption (Cond Fan+Compressor) at reduced test condition [W] Real64 NetCoolingCapReduced(0.0); // Net Cooling Coil capacity at reduced conditions, accounting for supply fan heat [W] Real64 LoadFactor(0.0); // Fractional "on" time for last stage at the desired reduced capacity, (dimensionless) - Real64 DegradationCoeff(0.0); // Degradation coeficient, (dimenssionless) + Real64 DegradationCoeff(0.0); // Degradation coefficient, (dimensionless) Real64 OutdoorUnitInletAirDryBulbTempReduced; // Outdoor unit entering air dry-bulb temperature at reduced capacity [C] // *** SOME CONSTANTS FROM THE STANDARD diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index a99dee14c4c..6eef10fab1d 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -591,7 +591,7 @@ namespace CondenserLoopTowers { cCurrentModuleObject, tower.Name, ". Tower Performance Input Method must be \"UFactorTimesAreaAndDesignWaterFlowRate\" or \"NominalCapacity\"")); - ShowContinueError(state, format("Tower Performanace Input Method currently specified as: {}", AlphArray(4))); + ShowContinueError(state, format("Tower Performance Input Method currently specified as: {}", AlphArray(4))); ErrorsFound = true; } if (NumAlphas > 12) { @@ -988,7 +988,7 @@ namespace CondenserLoopTowers { cCurrentModuleObject, tower.Name, R"(". Tower Performance Input Method must be "UFactorTimesAreaAndDesignWaterFlowRate" or "NominalCapacity".)")); - ShowContinueError(state, format("Tower Performanace Input Method currently specified as: {}", AlphArray(4))); + ShowContinueError(state, format("Tower Performance Input Method currently specified as: {}", AlphArray(4))); ErrorsFound = true; } if (NumAlphas > 11) { @@ -2398,7 +2398,7 @@ namespace CondenserLoopTowers { Real64 DesTowerExitWaterTemp; // design tower exit water temperature Real64 DesTowerWaterDeltaT; // design tower temperature range Real64 DesTowerApproachFromPlant; // design tower approach temperature from plant sizing object - Real64 TolTemp(0.04); // DeltaT and DesApproach diffs tollerance between plant sizing data and user input in cooling tower + Real64 TolTemp(0.04); // DeltaT and DesApproach diffs tolerance between plant sizing data and user input in cooling tower // for warning message reporting purpose only Real64 tmpDesignWaterFlowRate = this->DesignWaterFlowRate; @@ -3429,7 +3429,7 @@ namespace CondenserLoopTowers { OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCRange, this->Name, this->DesignRange); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCApproach, this->Name, this->DesignApproach); OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // eqival to Design Fan Power? + state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // equivalent to Design Fan Power? OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCDesInletAirWBT, this->Name, this->DesInletAirWBTemp); OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCDesWaterFlowRate, this->Name, this->DesignWaterFlowRate); @@ -3518,7 +3518,7 @@ namespace CondenserLoopTowers { Real64 DesTowerExitWaterTemp; // design tower exit water temperature Real64 DesTowerWaterDeltaT; // design tower temperature range Real64 DesTowerApproachFromPlant; // design tower approach temperature from plant sizing object - Real64 TolTemp(0.04); // DeltaT and DesApproach diffs tollerance between plant sizing data and user input in cooling tower + Real64 TolTemp(0.04); // DeltaT and DesApproach diffs tolerance between plant sizing data and user input in cooling tower // for warning message reporting purpose only // Find the appropriate Plant Sizing object @@ -3564,7 +3564,7 @@ namespace CondenserLoopTowers { PlantSizData(PltSizCondNum).PlantLoopName)); ShowContinueError(state, format("..The Design Range Temperature specified in tower is = {:.2T}", this->DesRange)); ShowContinueError(state, - format("..The Design Loop Delta Temperature specified iin plant sizing data is = {:.2T}", + format("..The Design Loop Delta Temperature specified in plant sizing data is = {:.2T}", PlantSizData(PltSizCondNum).DeltaT)); } // check if the tower approach is different from plant sizing data @@ -3867,7 +3867,7 @@ namespace CondenserLoopTowers { } } - // now calcuate UA values from nominal capacities and flow rates + // now calculate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { if (PltSizCondNum > 0) { // user has a plant sizing object Cp = FluidProperties::GetSpecificHeatGlycol(state, @@ -4205,7 +4205,7 @@ namespace CondenserLoopTowers { } } } - // now calcuate UA values from nominal capacities and flow rates + // now calculate UA values from nominal capacities and flow rates if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { rho = FluidProperties::GetDensityGlycol(state, state.dataPlnt->PlantLoop(this->plantLoc.loopNum).FluidName, @@ -4765,7 +4765,7 @@ namespace CondenserLoopTowers { } // Calculate bypass fraction since OWTLowerLimit < OutletWaterTemp < TempSetPoint. - // The iteraction ends when the numer of iteraction exceeds the limit or the difference + // The iteration ends when the number of iterations exceeds the limit or the difference // between the new and old bypass fractions is less than the threshold. if (BypassFlag == 1) { // Inlet water temperature lower than setpoint, assume 100% bypass, tower fan off @@ -4803,7 +4803,7 @@ namespace CondenserLoopTowers { this->OutletWaterTemp = this->calculateSimpleTowerOutletTemp( state, WaterMassFlowRatePerCell * (1.0 - BypassFraction2), AirFlowRate, UAdesign); if (this->OutletWaterTemp < OWTLowerLimit) { - // Use previous iteraction values + // Use previous iteration values BypassFraction2 = BypassFractionPrev; this->OutletWaterTemp = OutletWaterTempPrev; } @@ -4867,7 +4867,7 @@ namespace CondenserLoopTowers { // Cyclic losses are neglected. The period of time required to meet the // leaving water temperature setpoint is used to determine the required // fan power and energy. Free convection regime is also modeled. This - // occures when the pump is operating and the fan is off. If free convection + // occurs when the pump is operating and the fan is off. If free convection // regime cooling is all that is required for a given time step, the leaving // water temperature is allowed to fall below the leaving water temperature // setpoint (free cooling). At times when the cooling tower fan is required, @@ -5663,7 +5663,7 @@ namespace CondenserLoopTowers { } } - // now rerun to get peformance with AirFlowRateRatio + // now rerun to get performance with AirFlowRateRatio AirFlowRatePerCell = this->airFlowRateRatio * this->HighSpeedAirFlowRate / this->NumCell; UAairflowAdjFac = Curve::CurveValue(state, this->UAModFuncAirFlowRatioCurvePtr, this->airFlowRateRatio); @@ -5983,7 +5983,7 @@ namespace CondenserLoopTowers { // calculate end time of current time step Real64 CurrentEndTime = state.dataGlobal->CurrentTime + state.dataHVACGlobal->SysTimeElapsed; - // Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. + // Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. // Wait for next time step to print warnings. If simulation iterates, print out // the warning for the last iteration only. Must wait for next time step to accomplish this. // If a warning occurs and the simulation down shifts, the warning is not valid. @@ -6207,7 +6207,7 @@ namespace CondenserLoopTowers { // A Flament, July 2010. Added multi-cell capability // PURPOSE OF THIS SUBROUTINE: - // Collect tower water useage calculations for reuse by all the tower models. + // Collect tower water usage calculations for reuse by all the tower models. // REFERENCES: // Code for this routine started from VariableSpeedTower @@ -6351,7 +6351,7 @@ namespace CondenserLoopTowers { state.dataGlobal->WarmupFlag) return; - // Check flow rate through tower and compare to design flow rate, show warning if greater than Design * Mulitplier + // Check flow rate through tower and compare to design flow rate, show warning if greater than Design * Multiplier if (state.dataLoopNodes->Node(this->WaterOutletNodeNum).MassFlowRate > this->DesWaterMassFlowRate * this->TowerMassFlowRateMultiplier) { ++this->HighMassFlowErrorCount; if (this->HighMassFlowErrorCount < 2) { diff --git a/src/EnergyPlus/DXCoils.cc b/src/EnergyPlus/DXCoils.cc index dc78db35aa7..3f9d45b9969 100644 --- a/src/EnergyPlus/DXCoils.cc +++ b/src/EnergyPlus/DXCoils.cc @@ -255,7 +255,7 @@ void SimDXCoilMultiSpeed(EnergyPlusData &state, Real64 const SpeedRatio, // = (CompressorSpeed - CompressorSpeedMin) / Real64 const CycRatio, // cycling part load ratio for variable speed int &CompIndex, - ObjexxFCL::Optional_int_const SpeedNum, // Speed number for multispeed cooling coil onlyn + ObjexxFCL::Optional_int_const SpeedNum, // Speed number for multispeed cooling coil only ObjexxFCL::Optional fanOp, // Fan operation mode HVAC::CompressorOp compressorOp, // Compressor on/off; 1=on, 0=off ObjexxFCL::Optional_int_const SingleMode // Single mode operation Yes/No; 1=Yes, 0=No @@ -1811,7 +1811,7 @@ void GetDXCoils(EnergyPlusData &state) thisDXCoil.RatedEIR(PerfModeNum) = 1.0 / thisDXCoil.RatedCOP(PerfModeNum); - // read in user specified SHR modifer curves + // read in user specified SHR modifier curves if (!lAlphaBlanks2(9) && NumAlphas2 > 8) { thisDXCoil.SHRFTemp(PerfModeNum) = GetCurveIndex(state, Alphas2(9)); // convert curve name to number if (thisDXCoil.SHRFTemp(PerfModeNum) == 0) { @@ -5257,7 +5257,7 @@ void GetDXCoils(EnergyPlusData &state) thisDXCoil.RatedSHR(1) = Numbers(2); thisDXCoil.SH = Numbers(3); // @@ DXCoil( DXCoilNum ).RateBFVRFIUEvap = 0.0592; there will be a new field for this, which will be handled in a separate issue to - // update VRF-HP idd. It is not hanlded here to avoide tranistion issues for VRF-HP. + // update VRF-HP idd. It is not handled here to avoid transition issues for VRF-HP. int indexSHCurve = GetCurveIndex(state, Alphas(5)); // convert curve name to index number // Verify curve name and type @@ -6836,7 +6836,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur thisDXCoil.RatedAirVolFlowRate(Mode), thisDXCoil.RatedSHR(Mode)); - // call coil model with everthing set at rating point + // call coil model with everything set at rating point thisDXCoil.InletAirMassFlowRate = thisDXCoil.RatedAirMassFlowRate(Mode); thisDXCoil.InletAirMassFlowRateMax = thisDXCoil.RatedAirMassFlowRate(Mode); thisDXCoil.InletAirTemp = RatedInletAirTemp; @@ -6998,7 +6998,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur } } - // call coil model with everthing set at rating point + // call coil model with everything set at rating point thisDXCoil.InletAirMassFlowRate = thisDXCoil.RatedAirMassFlowRate(Mode); thisDXCoil.InletAirMassFlowRateMax = thisDXCoil.RatedAirMassFlowRate(Mode); @@ -7096,7 +7096,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur thisDXCoil.RatedAirVolFlowRate2, thisDXCoil.RatedSHR2); - // call for standard ratings for two-speeed DX coil + // call for standard ratings for two-speed DX coil if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air) { CalcTwoSpeedDXCoilStandardRating(state, DXCoilNum); } @@ -7241,7 +7241,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) // Feb 2005, M. J. Witte, GARD Analytics, Inc. Add new coil type COIL:DX:MultiMode:CoolingEmpirical. // Jul 2005, R. Raustad, FSEC. Add new coil type COIL:DX:HEATPUMPWATERHEATER // Jun 2007, L. Gu, FSEC. Add new coil type COIL:DX:MULTISPEED:COOLING and HEATING - // Jan 2011, B. Griffithn, NREL. add EMS overrides for autosized fields + // Jan 2011, B. Griffith, NREL. add EMS overrides for autosized fields // Aug 2013, D. Kang. add component sizing table entries // May 2014, R. Raustad, FSEC. moved sizing calculations to common routine // Aug 2015, R. Zhang, LBNL. Add new coil types for VRF_FluidTCtrl @@ -7391,7 +7391,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) state.dataSize->DXCoolCap; // pass global variable used only for heat pumps (i.e., DX cooling and heating coils) if ((thisDXCoil.IsSecondaryDXCoilInZone) && (thisDXCoil.CondenserType(1) == - DataHeatBalance::RefrigCondenserType::Air)) { // seconday DX coil in secondary zone is specified + DataHeatBalance::RefrigCondenserType::Air)) { // secondary DX coil in secondary zone is specified SizeSecDXCoil = true; } } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating) { @@ -7925,7 +7925,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) state.dataSize->DataFractionUsedForSizing = 0.0; } - // Ensure flow rate at lower speed must be lower or equal to the flow rate at higher speed. Otherwise, a severe error is isssued. + // Ensure flow rate at lower speed must be lower or equal to the flow rate at higher speed. Otherwise, a severe error is issued. for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds - 1; ++Mode) { if (thisDXCoil.MSRatedAirVolFlowRate(Mode) > thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)) { ShowWarningError(state, @@ -8049,7 +8049,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) thisDXCoil.MSRatedSHR(Mode) = sizerCoolingSHR.size(state, TempSize, ErrorsFound); // added for rated sensible cooling capacity estimate for html reporting, issue #7381 thisDXCoil.RatedSHR(1) = thisDXCoil.MSRatedSHR(Mode); - // design SHR value at the maxiumum speed calculated above was supposed to be used for all speeds + // design SHR value at the maximum speed calculated above was supposed to be used for all speeds // Now user specified SHR value is used when the SHR field is not autosized and design day run is // set to yes unless the code below is commented out MSRatedSHRDes = thisDXCoil.MSRatedSHR(Mode); @@ -8071,7 +8071,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) state.dataSize->DataFractionUsedForSizing = 0.0; state.dataSize->DataConstantUsedForSizing = 0.0; - // Rated Evapovative condenser airflow rates + // Rated Evaporative condenser airflow rates for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds; ++Mode) { IsAutoSize = false; if (thisDXCoil.MSEvapCondAirFlow(Mode) == AutoSize) { @@ -8134,7 +8134,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) } } - // Sizing multispeed rated evapovative condenser pump power + // Sizing multispeed rated evaporative condenser pump power for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds; ++Mode) { IsAutoSize = false; if (thisDXCoil.MSEvapCondPumpElecNomPower(Mode) == AutoSize) { @@ -8185,7 +8185,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) } } - // Ensure evaporative condesner pump power at lower speed must be lower or equal to one at higher speed. + // Ensure evaporative condenser pump power at lower speed must be lower or equal to one at higher speed. for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds - 1; ++Mode) { if (thisDXCoil.MSEvapCondPumpElecNomPower(Mode) > thisDXCoil.MSEvapCondPumpElecNomPower(Mode + 1)) { ShowWarningError(state, @@ -8263,7 +8263,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum) state.dataSize->DataFractionUsedForSizing = 0.0; } - // Ensure flow rate at lower speed must be lower or equal to the flow rate at higher speed. Otherwise, a severe error is isssued. + // Ensure flow rate at lower speed must be lower or equal to the flow rate at higher speed. Otherwise, a severe error is issued. for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds - 1; ++Mode) { if (thisDXCoil.MSRatedAirVolFlowRate(Mode) > thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)) { ShowWarningError(state, @@ -9234,7 +9234,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state, // calculate end time of current time step to determine if error messages should be printed state.dataDXCoils->CurrentEndTime = state.dataGlobal->CurrentTime + SysTimeElapsed; - // Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. + // Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. // Wait for next time step to print warnings. If simulation iterates, print out // the warning for the last iteration only. Must wait for next time step to accomplish this. // If a warning occurs and the simulation down shifts, the warning is not valid. @@ -9437,7 +9437,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state, } // Get total capacity modifying factor (function of temperature) for off-rated conditions - // InletAirHumRat may be modified in this ADP/BF loop, use temporary varible for calculations + // InletAirHumRat may be modified in this ADP/BF loop, use temporary variable for calculations InletAirHumRatTemp = InletAirHumRat; AirMassFlowRatio = AirMassFlow / thisDXCoil.RatedAirMassFlowRate(Mode); while (true) { @@ -10049,7 +10049,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state, // of entering air temperatures and supply air flow rate (actual vs rated flow). The model // does NOT employ the exact same methodology to calculate performance as DOE-2. // This VRF cooling coil model adjusts the rated total cooling capacity by the CAPFT - // and CAP funciton of flow curve/model currently used by the existing DX coil model. + // and CAP function of flow curve/model currently used by the existing DX coil model. // The part-load ratio is then applied to the total operating capacity to find the capacity // required to meet the load. This VRF model then uses the ADP/bypass method to find the // SHR and resulting outlet conditions given that total capacity (or delta H). @@ -10221,7 +10221,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state, // calculate end time of current time step to determine if error messages should be printed state.dataDXCoils->CalcVRFCoolingCoilCurrentEndTime = state.dataGlobal->CurrentTime + SysTimeElapsed; - // Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. + // Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. // Wait for next time step to print warnings. If simulation iterates, print out // the warning for the last iteration only. Must wait for next time step to accomplish this. // If a warning occurs and the simulation down shifts, the warning is not valid. @@ -10402,7 +10402,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state, } // Get total capacity modifying factor (function of temperature) for off-rated conditions - // InletAirHumRat may be modified in this ADP/BF loop, use temporary varible for calculations + // InletAirHumRat may be modified in this ADP/BF loop, use temporary variable for calculations InletAirHumRatTemp = InletAirHumRat; Label50:; @@ -10742,7 +10742,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state, // REFERENCES: // Winkelmann, F.C., Birdsall, B.E., Buhl W.F., Ellington, K.L., Erdem, A.E. 1993. - // DOE-2 Supplement Version 2.1E. Energy and Environment Division, Larwence Berkely + // DOE-2 Supplement Version 2.1E. Energy and Environment Division, Lawrence Berkeley // Laboratory. // Henderson, H.I. Jr., Y.J. Huang and Danny Parker. 1999. Residential Equipment Part // Load Curves for Use in DOE-2. Environmental Energy Technologies Division, Ernest @@ -10912,7 +10912,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state, // Get total capacity modifying factor (function of temperature) for off-rated conditions // Model was extended to accept bi-quadratic curves. This allows sensitivity of the heating capacity // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is - // advised to use the bi-quaratic curve if sufficient manufacturer data is available. + // advised to use the bi-quadratic curve if sufficient manufacturer data is available. if (state.dataCurveManager->PerfCurve(thisDXCoil.CCapFTemp(Mode))->numDims == 2) { switch (thisDXCoil.HeatingPerformanceOATType) { case HVAC::OATType::DryBulb: { @@ -11051,7 +11051,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state, // Calculate electricity consumed. First, get EIR modifying factors for off-rated conditions // Model was extended to accept bi-quadratic curves. This allows sensitivity of the EIR // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is - // advised to use the bi-quaratic curve if sufficient manufacturer data is available. + // advised to use the bi-quadratic curve if sufficient manufacturer data is available. if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) { if (state.dataCurveManager->PerfCurve(thisDXCoil.EIRFTemp(Mode))->numDims == 1) { EIRTempModFac = CurveValue(state, thisDXCoil.EIRFTemp(Mode), OutdoorDryBulb); @@ -11623,7 +11623,7 @@ void CalcMultiSpeedDXCoil(EnergyPlusData &state, if (thisDXCoil.CoolingCoilRuntimeFraction > 1.0) { thisDXCoil.CoolingCoilRuntimeFraction = 1.0; // Reset coil runtime fraction to 1.0 } - // get the eletrical power consumption + // get the electrical power consumption thisDXCoil.ElecCoolingPower = TotCapLS * EIRLS * thisDXCoil.CoolingCoilRuntimeFraction; // Coil total/sensible/latent cooling rates and electrical power @@ -12052,7 +12052,7 @@ Real64 ValidateADP(EnergyPlusData &state, // DATE WRITTEN December 2015 // PURPOSE OF THIS FUNCTION: - // Validates that the calcualted bypass factor represents valid SHR based on total capacity and air mass flow rate. + // Validates that the calculated bypass factor represents valid SHR based on total capacity and air mass flow rate. // METHODOLOGY EMPLOYED: // With model parameters autosized by the user, the SHR is selected based on an empirical model. @@ -12223,7 +12223,7 @@ Real64 CalcEffectiveSHR(EnergyPlusData &state, Twet = min(Twet_Rated * QLatRated / (QLatActual + 1.e-10), Twet_max); Gamma = Gamma_Rated * QLatRated * (EnteringDB - EnteringWB) / ((26.7 - 19.4) * QLatActual + 1.e-10); - // Calculate the compressor on and off times using a converntional thermostat curve + // Calculate the compressor on and off times using a conventional thermostat curve Ton = 3600.0 / (4.0 * Nmax * (1.0 - RTF)); // duration of cooling coil on-cycle (sec) Toff = 3600.0 / (4.0 * Nmax * RTF); // duration of cooling coil off-cycle (sec) @@ -12239,7 +12239,7 @@ Real64 CalcEffectiveSHR(EnergyPlusData &state, // and real world applications would use a single heating coil for both purposes, the actual // fan operation is based on HeatingPLR + ReheatPLR. For cycling fan RH control, latent // degradation only occurs when a heating load exists, in this case the reheat load is - // equal to and oposite in magnitude to the cooling coil sensible output but the reheat + // equal to and opposite in magnitude to the cooling coil sensible output but the reheat // coil is not always active. This additional fan run time has not been accounted for at this time. // Recalculate Toff for cycling fan systems when heating is active if (present(HeatingRTF)) { @@ -12252,7 +12252,7 @@ Real64 CalcEffectiveSHR(EnergyPlusData &state, } } - // Use sucessive substitution to solve for To + // Use successive substitution to solve for To aa = (Gamma * Toffa) - (0.25 / Twet) * pow_2(Gamma) * pow_2(Toffa); To1 = aa + Tcl; Error = 1.0; @@ -12471,7 +12471,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state, Real64 LSOutletAirDryBulbTemp; // low speed outlet air dry bulb temperature [C] Real64 LSOutletAirEnthalpy; // low speed outlet air enthalpy [J/kg] Real64 LSOutletAirHumRat; // low speed outlet air humidity ratio [kg/kg] - Real64 HSOutletAirDryBulbTemp; // hihg speed outlet air dry bulb temperature [C] + Real64 HSOutletAirDryBulbTemp; // high speed outlet air dry bulb temperature [C] Real64 HSOutletAirEnthalpy; // high speed outlet air enthalpy [J/kg] Real64 HSOutletAirHumRat; // high speed outlet air humidity ratio [kg/kg] Real64 hDelta; // Change in air enthalpy across the cooling coil [J/kg] @@ -13147,7 +13147,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state, EIRFlowModFacLS = CurveValue(state, thisDXCoil.MSEIRFFlow(SpeedNum), AirMassFlowRatioLS); EIRLS = 1.0 / thisDXCoil.MSRatedCOP(SpeedNum) * EIRTempModFacLS * EIRFlowModFacLS; - // get the eletrical power consumption + // get the electrical power consumption thisDXCoil.ElecCoolingPower = TotCapLS * EIRLS * thisDXCoil.CoolingCoilRuntimeFraction; // calculate cooling output power // AirMassFlow = DXCoil(DXCoilNum)%InletAirMassFlowRate @@ -13341,22 +13341,22 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state, Real64 CrankcaseHeatingPower; // Power due to crank case heater Real64 AirVolumeFlowRate; // Air volume flow rate across the heating coil Real64 VolFlowperRatedTotCap; // Air volume flow rate divided by rated total heating capacity - Real64 TotCapTempModFac(0.0); // Total capacity modifier as a function ot temperature + Real64 TotCapTempModFac(0.0); // Total capacity modifier as a function of temperature Real64 TotCapFlowModFac; // Total capacity modifier as a function of flow ratio Real64 OutdoorCoilT; // Outdoor coil temperature Real64 OutdoorCoildw; // Outdoor coil delta w assuming coil temperature of OutdoorCoilT - Real64 LoadDueToDefrost; // Additonal load due to defrost - Real64 LoadDueToDefrostLS; // Additonal load due to defrost at low speed - Real64 LoadDueToDefrostHS; // Additonal load due to defrost at high speed + Real64 LoadDueToDefrost; // Additional load due to defrost + Real64 LoadDueToDefrostLS; // Additional load due to defrost at low speed + Real64 LoadDueToDefrostHS; // Additional load due to defrost at high speed Real64 HeatingCapacityMultiplier; // Multiplier for heating capacity when system is in defrost Real64 FractionalDefrostTime; // Fraction of time step when system is in defrost - Real64 InputPowerMultiplier; // Multiplier for poer when system is in defrost + Real64 InputPowerMultiplier; // Multiplier for power when system is in defrost Real64 DefrostEIRTempModFac; // EIR modifier for defrost Real64 FullLoadOutAirEnth; // Outlet full load enthalpy Real64 FullLoadOutAirHumRat; // Outlet humidity ratio at full load Real64 FullLoadOutAirTemp; // Outlet temperature at full load - Real64 FullLoadOutAirRH; // Outler relative humidity at full load - Real64 OutletAirTemp; // Supply ari temperature + Real64 FullLoadOutAirRH; // Outlet relative humidity at full load + Real64 OutletAirTemp; // Supply air temperature Real64 EIRTempModFac(0.0); // EIR modifier as a function of temperature Real64 EIRFlowModFac; // EIR modifier as a function of airflow ratio Real64 WasteHeatLS; // Waste heat at low speed @@ -13553,7 +13553,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state, // Get total capacity modifying factor (function of temperature) for off-rated conditions // Model was extended to accept bi-quadratic curves. This allows sensitivity of the heating capacity // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is - // advised to use the bi-quaratic curve if sufficient manufacturer data is available. + // advised to use the bi-quadratic curve if sufficient manufacturer data is available. // Low speed if (state.dataCurveManager->PerfCurve(thisDXCoil.MSCCapFTemp(SpeedNumLS))->numDims == 1) { TotCapTempModFac = CurveValue(state, thisDXCoil.MSCCapFTemp(SpeedNumLS), OutdoorDryBulb); @@ -13577,7 +13577,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state, // Calculate electricity consumed. First, get EIR modifying factors for off-rated conditions // Model was extended to accept bi-quadratic curves. This allows sensitivity of the EIR // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is - // advised to use the bi-quaratic curve if sufficient manufacturer data is available. + // advised to use the bi-quadratic curve if sufficient manufacturer data is available. // Low Speed if (state.dataCurveManager->PerfCurve(thisDXCoil.MSEIRFTemp(SpeedNumLS))->numDims == 1) { EIRTempModFac = CurveValue(state, thisDXCoil.MSEIRFTemp(SpeedNumLS), OutdoorDryBulb); @@ -13798,7 +13798,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state, // Get total capacity modifying factor (function of temperature) for off-rated conditions // Model was extended to accept bi-quadratic curves. This allows sensitivity of the heating capacity // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is - // advised to use the bi-quaratic curve if sufficient manufacturer data is available. + // advised to use the bi-quadratic curve if sufficient manufacturer data is available. if (state.dataCurveManager->PerfCurve(thisDXCoil.MSCCapFTemp(SpeedNum))->numDims == 1) { TotCapTempModFac = CurveValue(state, thisDXCoil.MSCCapFTemp(SpeedNum), OutdoorDryBulb); } else { @@ -14702,7 +14702,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum newPreDefSubTable(state, state.dataOutRptPredefined->pdrEquip, "VAV DX Cooling Standard Rating Details"); state.dataOutRptPredefined->pdchVAVDXCoolCoilType = newPreDefColumn(state, state.dataOutRptPredefined->pdstVAVDXCoolCoil, "DX Cooling Coil Type"); - state.dataOutRptPredefined->pdchVAVDXFanName = newPreDefColumn(state, state.dataOutRptPredefined->pdstVAVDXCoolCoil, "Assocated Fan"); + state.dataOutRptPredefined->pdchVAVDXFanName = newPreDefColumn(state, state.dataOutRptPredefined->pdstVAVDXCoolCoil, "Associated Fan"); state.dataOutRptPredefined->pdchVAVDXCoolCoilNetCapSI = newPreDefColumn(state, state.dataOutRptPredefined->pdstVAVDXCoolCoil, "Net Cooling Capacity [W]"); state.dataOutRptPredefined->pdchVAVDXCoolCoilCOP = newPreDefColumn(state, state.dataOutRptPredefined->pdstVAVDXCoolCoil, "COP [W/W]"); @@ -15582,7 +15582,7 @@ int GetDXCoilAvailSchPtr(EnergyPlusData &state, // as -1. // Return value - int SchPtr; // returned availabiltiy schedule of matched coil + int SchPtr; // returned availability schedule of matched coil // FUNCTION LOCAL VARIABLE DECLARATIONS: int WhichCoil; @@ -15723,7 +15723,7 @@ int GetDXCoilCapFTCurveIndex(EnergyPlusData &state, default: { // CALL ShowSevereError(state, 'GetDXCoilCapFTCurveIndex: Could not find Coil, Type="'// & // TRIM(cAllCoilTypes(DXCoil(CoilIndex)%DXCoilType_Num))//'" Name="'//TRIM(DXCoil(CoilIndex)%Name)// & - // '" when accessing coil capacity as a function of temperture curve.') + // '" when accessing coil capacity as a function of temperature curve.') ErrorsFound = true; CapFTCurveIndex = 0; } break; @@ -15967,14 +15967,14 @@ Real64 CalcSHRUserDefinedCurves(EnergyPlusData &state, // DATE WRITTEN December 2012 // PURPOSE OF THIS FUNCTION: - // Returns the oprating sensible heat ratio for a given Rated SHR abd coil entering + // Returns the operating sensible heat ratio for a given Rated SHR and coil entering // air DBT and WBT, and supply air mass flow fraction. // METHODOLOGY EMPLOYED: // Model uses user specified rated SHR, and SHR modifying curves for temperature and flow // fraction. The curves adjust the rated SHR based on biquadratic curve for temperatures // and quadratic function for supply air mass flow ratio (actual vs rated). - // The biquadratic and quadratic curves are normalized caurves generated from manufacturer's + // The biquadratic and quadratic curves are normalized curves generated from manufacturer's // performance data // Using/Aliasing @@ -16087,10 +16087,10 @@ void CalcSecondaryDXCoils(EnergyPlusData &state, int const DXCoilNum) Real64 TotalHeatRejectionRate; // secondary coil total heat rejection rate int SecCoilSHRFT; // index of the SHR modifier curve for temperature of a secondary DX coil int SecCoilSHRFF; // index of the sHR modifier curve for flow fraction of a secondary DX coil - int MSSpeedNumLS; // current low speed number of multspeed HP - int MSSpeedNumHS; // current high speed number of multspeed HP - Real64 MSSpeedRatio; // current speed ratio of multspeed HP - Real64 MSCycRatio; // current cycling ratio of multspeed HP + int MSSpeedNumLS; // current low speed number of multispeed HP + int MSSpeedNumHS; // current high speed number of multispeed HP + Real64 MSSpeedRatio; // current speed ratio of multispeed HP + Real64 MSCycRatio; // current cycling ratio of multispeed HP Real64 SHRHighSpeed; // sensible heat ratio at high speed Real64 SHRLowSpeed; // sensible heat ratio at low speed @@ -16335,9 +16335,9 @@ Real64 CalcSecondaryDXCoilsSHR(EnergyPlusData &state, // METHODOLOGY EMPLOYED: // Energy balance: - // (1) checks if the seconday coil operation is dry and calculates appliavle SHR. + // (1) checks if the secondary coil operation is dry and calculates applicable SHR. // (2) determines SHR from user specified rated SHR values and SHR modifier curves for - // temperature and flor fraction. + // temperature and flow fraction. // (3) if secondary coil operates dry then the larger of the user SHR value and dry // coil operation SHR is selected. @@ -16356,13 +16356,13 @@ Real64 CalcSecondaryDXCoilsSHR(EnergyPlusData &state, Real64 DryCoilTestEvapInletWetBulb; // evaporator coil inlet dry bulb temperature test for dry coil Real64 FullLoadOutAirEnth; // evaporator outlet full load enthalpy [J/kg] Real64 FullLoadOutAirTemp; // evaporator outlet air temperature at full load [C] - Real64 hTinwADP; // enthaly of air at secondary coil entering temperature and Humidity ratio at ADP + Real64 hTinwADP; // enthalpy of air at secondary coil entering temperature and Humidity ratio at ADP Real64 SHRadp; // Sensible heat ratio - Real64 hADP; // enthaly of air at secondary coil at ADP + Real64 hADP; // enthalpy of air at secondary coil at ADP Real64 tADP; // dry bulb temperature of air at secondary coil at ADP Real64 wADP; // humidity ratio of air at secondary coil at ADP Real64 HumRatError; // humidity ratio error - bool CoilMightBeDry; // TRUE means the secondary DX coi runs dry + bool CoilMightBeDry; // TRUE means the secondary DX coil runs dry int Counter; // iteration counter bool Converged; // convergence flag Real64 SHR; // current time step sensible heat ratio of secondary coil diff --git a/src/EnergyPlus/EcoRoofManager.cc b/src/EnergyPlus/EcoRoofManager.cc index 978713dff92..845bea086de 100644 --- a/src/EnergyPlus/EcoRoofManager.cc +++ b/src/EnergyPlus/EcoRoofManager.cc @@ -194,7 +194,7 @@ namespace EcoRoofManager { auto const &thisConstruct = state.dataConstruction->Construct(ConstrNum); auto const *thisMaterial = state.dataMaterial->materials(thisConstruct.LayerPoint(1)); RoughSurf = thisMaterial->Roughness; - Real64 AbsThermSurf = thisMaterial->AbsorpThermal; // Thermal absoptance of the exterior surface + Real64 AbsThermSurf = thisMaterial->AbsorpThermal; // Thermal absorptance of the exterior surface Real64 HMovInsul = 0.0; // "Convection" coefficient of movable insulation if (state.dataSurface->Surface(SurfNum).ExtWind) { @@ -284,7 +284,7 @@ namespace EcoRoofManager { // (Deardorff (1987)). Kelvin. based of the previous temperatures Tafk = (1.0 - sigmaf) * Tak + sigmaf * (0.3 * Tak + 0.6 * (Tif + Constant::Kelvin) + 0.1 * Tgk); - Taf = Tafk - Constant::Kelvin; // Air Temperature within canopy in Celcius (C). + Taf = Tafk - Constant::Kelvin; // Air Temperature within canopy in Celsius (C). Rhof = state.dataEcoRoofMgr->Pa / (Rair * Tafk); // Density of air at the leaf temperature Rhoaf = (Rhoa + Rhof) / 2.0; // Average of air density Zd = 0.701 * std::pow(state.dataEcoRoofMgr->Zf, 0.979); // Zero displacement height @@ -316,7 +316,7 @@ namespace EcoRoofManager { ra = 1.0 / (Cf * Waf); // Aerodynamic Resistance. Resistance that is caused // by the boundary layer on a leaf surface to transfer water vapor. It is measured in // s/m and depends on wind speed, leaf's surface roughness, - // and stability of atsmophere. + // and stability of atmosphere. CalculateEcoRoofSolar(state, RS, f1, SurfNum); if (state.dataEcoRoofMgr->MoistureMax == state.dataEcoRoofMgr->MoistureResidual) { @@ -525,9 +525,9 @@ namespace EcoRoofManager { thisEcoRoof->LAI = matER->LAI; // Leaf Area Index thisEcoRoof->Alphag = 1.0 - matER->AbsorpSolar; // albedo rather than absorptivity thisEcoRoof->Alphaf = matER->Lreflectivity; // Leaf Reflectivity - thisEcoRoof->epsilonf = matER->LEmissitivity; // Leaf Emisivity + thisEcoRoof->epsilonf = matER->LEmissitivity; // Leaf Emissivity thisEcoRoof->StomatalResistanceMin = matER->RStomata; // Leaf min stomatal resistance - thisEcoRoof->epsilong = matER->AbsorpThermal; // Soil Emisivity + thisEcoRoof->epsilong = matER->AbsorpThermal; // Soil Emissivity thisEcoRoof->MoistureMax = matER->Porosity; // Max moisture content in soil thisEcoRoof->MoistureResidual = matER->MinMoisture; // Min moisture content in soil thisEcoRoof->Moisture = matER->InitMoisture; // Initial moisture content in soil @@ -886,7 +886,7 @@ namespace EcoRoofManager { // the water will simply run right off the top and not penetrate at all! // At the present time this limit is fairly small due to some minor stability issues // in EnergyPlus. If the moisture changes too rapidly the code cannot handle the rapid changes in - // surface characteristics and heat fluxes. The result that I've noticed is a non-physical fluctation + // surface characteristics and heat fluxes. The result that I've noticed is a non-physical fluctuation // in ground surface temperature that oscillates up to 10 deg C from one hour to the next until the // code catches up. The temporary solution is to simply limit how much moisture can enter the soil // in any time step to 0.5"/hour. In the future this might be fixed by running with finer time steps @@ -913,12 +913,12 @@ namespace EcoRoofManager { if (matER->calcMethod == Material::EcoRoofCalcMethod::Simple) { // THE SECTION BELOW WAS THE INITIAL MOISTURE DISTRIBUTION MODEL. - // Any line with "!-" was code. A line with "!" was just a comment. This is done in case this code needs to be resurected in the future. + // Any line with "!-" was code. A line with "!" was just a comment. This is done in case this code needs to be resurrected in the future. // See below this commented out code for the new moisture distribution model. //********************************************************************************************************* //********************************************************************************************************* // NEXT Redistribute moisture based on moisture diffusion. - // The effective diffusivities should be revisted when better moisture transport data in ecoroof soils are + // The effective diffusivities should be revisited when better moisture transport data in ecoroof soils are // available. // Here the diffusion rate is in units of [1/s] // A value of 0.0001 would be ~ 36% / hour @@ -1072,7 +1072,7 @@ namespace EcoRoofManager { // Note wet soil absorptance is generally 25-50% higher than dry soil absorptance (assume linear) SoilAbsorpSolar = state.dataEcoRoofMgr->DryAbsorp + (0.92 - state.dataEcoRoofMgr->DryAbsorp) * (Moisture - MoistureResidual) / (MoistureMax - MoistureResidual); - // Limit solar absorptivity to 95% so soil abledo is always above 5% + // Limit solar absorptivity to 95% so soil albedo is always above 5% if (SoilAbsorpSolar > 0.95) SoilAbsorpSolar = 0.95; // Limit solar absorptivity to greater than 20% so that albedo is always less than 80% if (SoilAbsorpSolar < 0.20) SoilAbsorpSolar = 0.20; diff --git a/src/EnergyPlus/EconomicTariff.cc b/src/EnergyPlus/EconomicTariff.cc index cb2ec0a5f6a..e00d8375c28 100644 --- a/src/EnergyPlus/EconomicTariff.cc +++ b/src/EnergyPlus/EconomicTariff.cc @@ -485,7 +485,7 @@ void GetInputEconomicsTariff(EnergyPlusData &state, bool &ErrorsFound) // true i } // type of demand window if (Util::SameString(state.dataIPShortCut->cAlphaArgs(7), "QuarterHour")) { - // check to make sure that the demand window and the TIMESTEP IN HOUR are consistant. + // check to make sure that the demand window and the TIMESTEP IN HOUR are consistent. { switch (state.dataGlobal->NumOfTimeStepInHour) { case 1: @@ -1275,7 +1275,7 @@ void GetLastWord(std::string const &lineOfText, std::string::size_type &endOfSca // Returns the last substring of the line of text to the // left of the endOfSubStrg pointer. A substring is - // delimitted by spaces. Quotes are not significant + // delimited by spaces. Quotes are not significant // (they are treated just like any other non-space character) // Scan the string from the end. @@ -2210,7 +2210,7 @@ void CreateDefaultComputation(EnergyPlusData &state) // into categories. // category SUM chg1Name chg2Name chg3Name // Since the dependency array has one target and multiple - // parameters, remainingPt is shown as a seperate equation that + // parameters, remainingPt is shown as a separate equation that // depends on namePt for Charge:Block. The equation will not be // displayed or processed except in the sort. // remainingPt NOOP namePt @@ -2219,21 +2219,21 @@ void CreateDefaultComputation(EnergyPlusData &state) // charge, ratchet or qualify. // chg1Name // It is also possible that two variables referenced within one - // object could include a dependancy relationship also. For + // object could include a dependency relationship also. For // example, the blkSzPt could be calculated using the same sourePt // in Charge:Block. // METHODOLOGY EMPLOYED: // Since some ECONOMCIS:* objects depend on other variables // first must create the order of when to perform the - // computations. First a dependancy table is created that - // indicates what variables are dependant on other variables. + // computations. First a dependency table is created that + // indicates what variables are dependent on other variables. // A directed acyclic graph (DAG) describes the general // problem which is usually solved using a topological // sorting algorithm. // Each line/step is generated and put into the depend // array. Also in the array are counts of how many items it - // depends on and a list of entries that are dependant on that + // depends on and a list of entries that are dependent on that // line. // for each tariff that does not have a UtilityCost:Computation object go through the variables @@ -2251,7 +2251,7 @@ void CreateDefaultComputation(EnergyPlusData &state) } //"clear" the dependOn array state.dataEconTariff->numOperand = 0; - // Define the preset equations (category sumation) + // Define the preset equations (category summation) int curTotal = tariff.ptTotal; int curSubtotal = tariff.ptSubtotal; int curBasis = tariff.ptBasis; @@ -2284,7 +2284,7 @@ void CreateDefaultComputation(EnergyPlusData &state) addOperand(state, tariff.ptEnergyCharges, tariff.nativeRealTimePriceCosts); } // now add equations with NOOP to represent each object with its - // dependancies + // dependencies // Qualify for (int kObj = 1; kObj <= state.dataEconTariff->numQualify; ++kObj) { auto const &qualify = state.dataEconTariff->qualify(kObj); @@ -2351,7 +2351,7 @@ void CreateDefaultComputation(EnergyPlusData &state) } } } - // make sure no compuation is already user defined + // make sure no computation is already user defined if (computation.firstStep != 0) { ShowWarningError(state, format("In UtilityCost:Tariff: Overwriting user defined tariff {}", tariff.tariffName)); } @@ -2361,13 +2361,13 @@ void CreateDefaultComputation(EnergyPlusData &state) computation.lastStep = -1; // this will be incremented by addStep computation.isUserDef = false; // now all "equations" are defined, treat the variables with the list - // of dependancies as a directed acyclic graph and use "count down" algorithm + // of dependencies as a directed acyclic graph and use "count down" algorithm // to do a topological sort of the variables into the order for computation // First, clear the counters for (int jVar = 1; jVar <= state.dataEconTariff->numEconVar; ++jVar) { state.dataEconTariff->econVar(jVar).cntMeDependOn = 0; } - // Second, add up the number of dependancies on each variable + // Second, add up the number of dependencies on each variable for (int iVar = 1; iVar <= state.dataEconTariff->numEconVar; ++iVar) { if (state.dataEconTariff->econVar(iVar).activeNow) { if (state.dataEconTariff->econVar(iVar).lastOperand >= state.dataEconTariff->econVar(iVar).firstOperand) { @@ -2384,7 +2384,7 @@ void CreateDefaultComputation(EnergyPlusData &state) numNoDepend = 0; for (int iVar = 1; iVar <= state.dataEconTariff->numEconVar; ++iVar) { if (state.dataEconTariff->econVar(iVar).activeNow) { - // find a variable that has no more dangling dependancies + // find a variable that has no more dangling dependencies if (state.dataEconTariff->econVar(iVar).cntMeDependOn == 0) { // If the variable is a native variable then // IF (econVar(iVar)%kindOfObj .NE. iEconVarObjType::Native) THEN @@ -2437,7 +2437,7 @@ void CreateDefaultComputation(EnergyPlusData &state) } if (loopCount > 100000) { ShowWarningError(state, - format("UtilityCost:Tariff: Loop count exceeded when counting dependancies in tariff: {}", tariff.tariffName)); + format("UtilityCost:Tariff: Loop count exceeded when counting dependencies in tariff: {}", tariff.tariffName)); } // make sure that all variables associated with the tariff are included bool remainingVarFlag = false; @@ -2450,7 +2450,7 @@ void CreateDefaultComputation(EnergyPlusData &state) ShowWarningError(state, format("CreateDefaultComputation: In UtilityCost:Computation: Circular or invalid dependencies found in tariff: {}", tariff.tariffName)); - ShowContinueError(state, " UtilityCost variables that may have invalid dependencies and the variables they are dependant on."); + ShowContinueError(state, " UtilityCost variables that may have invalid dependencies and the variables they are dependent on."); for (int iVar = 1; iVar <= state.dataEconTariff->numEconVar; ++iVar) { if (state.dataEconTariff->econVar(iVar).tariffIndx == iTariff) { if (state.dataEconTariff->econVar(iVar).activeNow) { @@ -2484,7 +2484,7 @@ void addOperand(EnergyPlusData &state, int const varMe, int const varOperand) // AUTHOR Jason Glazer of GARD Analytics, Inc. // DATE WRITTEN July 2004 - // Used by CreateDefaultComputation to create the dependancy + // Used by CreateDefaultComputation to create the dependency // relationship in the EconVar array int constexpr sizeIncrement(100); @@ -3148,7 +3148,7 @@ void pushStack(EnergyPlusData &state, Array1A const monthlyArray, int co } // if the serviceCharges are being evaluated add in the monthly charges if (econVar(variablePointer).specific == catServiceCharges) addMonthlyCharge(state, variablePointer); - // get the results of performing the evaulation - should have been + // get the results of performing the evaluation - should have been // put into the econVar values curMonthlyArray = econVar(variablePointer).values; } @@ -3298,7 +3298,7 @@ void evaluateChargeBlock(EnergyPlusData &state, int const usingVariable) } else { blkSzMult = chargeBlock.blkSzMultVal; } - // initially set the remaing energy or demand to the source + // initially set the remaining energy or demand to the source remainVals = sourceVals; // initially set the result (cost) to zero resultChg = 0.0; @@ -3607,7 +3607,7 @@ void evaluateQualify(EnergyPlusData &state, int const usingVariable) } } // now update the tariff level qualifier - only update if the tariff is still qualified - // and the current qualifer fails. + // and the current qualifier fails. if (tariff.isQualified) { if (!isQualified) { tariff.isQualified = false; @@ -4743,7 +4743,7 @@ void selectTariff(EnergyPlusData &state) // DATE WRITTEN July 2004 // To select tariffs for each combination of meter and - // group. If multipler tariffs have the same meter and + // group. If multiple tariffs have the same meter and // group, then select the one with the lowest cost. // For electric tariffs, since they may have buy, sell, or // netmetering, they need to be combined more carefully. diff --git a/src/EnergyPlus/ElectricBaseboardRadiator.cc b/src/EnergyPlus/ElectricBaseboardRadiator.cc index 7970a0034b9..4197f92642a 100644 --- a/src/EnergyPlus/ElectricBaseboardRadiator.cc +++ b/src/EnergyPlus/ElectricBaseboardRadiator.cc @@ -84,7 +84,7 @@ namespace ElectricBaseboardRadiator { // PURPOSE OF THIS MODULE: // This module is to calculate the actual convective heat addition that an electrical baseboard heater - // deliveres to a space. + // delivers to a space. // METHODOLOGY EMPLOYED: // Based on the convective-only electric baseboard module (Object: ZoneHVAC:Baseboard:Convective:Electric) @@ -888,7 +888,7 @@ namespace ElectricBaseboardRadiator { // April 2010 Brent Griffith, max limit to protect surface temperature calcs // PURPOSE OF THIS SUBROUTINE: - // To distribute the gains from the electric basebaord heater + // To distribute the gains from the electric baseboard heater // as specified in the user input file. This includes distribution // of long wavelength radiant gains to surfaces and "people." diff --git a/src/EnergyPlus/EvaporativeCoolers.cc b/src/EnergyPlus/EvaporativeCoolers.cc index ae2801a861e..b8141370b50 100644 --- a/src/EnergyPlus/EvaporativeCoolers.cc +++ b/src/EnergyPlus/EvaporativeCoolers.cc @@ -93,7 +93,7 @@ namespace EnergyPlus::EvaporativeCoolers { // AUTHOR Richard J. Liesen // DATE WRITTEN Oct 2000 // MODIFIED BG July 2003 ResearchSpecial Indirect -// BG Febraury 2007 outside air nodes +// BG February 2007 outside air nodes // BG March 2009 ResearchSpecial Direct // RE-ENGINEERED na @@ -1189,7 +1189,7 @@ void SizeEvapCooler(EnergyPlusData &state, int const EvapCoolNum) if (CurSysNum > 0) { CheckThisAirSystemForSizing(state, CurSysNum, SizingDesRunThisAirSys); if (SizingDesRunThisAirSys) { - HardSizeNoDesRun = false; // Check if design infomation is available + HardSizeNoDesRun = false; // Check if design information is available } } if (CurZoneEqNum > 0) { @@ -1199,7 +1199,7 @@ void SizeEvapCooler(EnergyPlusData &state, int const EvapCoolNum) // This check was commented to get back to original code and an issue is needed to correct. // Why no check for zone equipment? // if (SizingDesRunThisZone) { - // HardSizeNoDesRun = false; // Check if design infomation is available + // HardSizeNoDesRun = false; // Check if design information is available //} } // I don't think the sizing logic is correct when it comes to autosized vs hard-sized inputs @@ -1400,7 +1400,7 @@ void SizeEvapCooler(EnergyPlusData &state, int const EvapCoolNum) if (CurSysNum > 0 && !IsAutoSize && !SizingDesRunThisAirSys) { HardSizeNoDesRun = true; } - if (SizingDesRunThisAirSys) HardSizeNoDesRun = false; // Check if design infomation is available + if (SizingDesRunThisAirSys) HardSizeNoDesRun = false; // Check if design information is available // Design air flow rate if (CurSysNum > 0) { // central system if (!IsAutoSize && !SizingDesRunThisAirSys) { @@ -1516,7 +1516,7 @@ void SizeEvapCooler(EnergyPlusData &state, int const EvapCoolNum) IsAutoSize = true; } if (SizingDesRunThisAirSys) { - HardSizeNoDesRun = false; // Check if design infomation is available + HardSizeNoDesRun = false; // Check if design information is available } // Design air flow rate if (CurSysNum > 0) { // central system @@ -1735,7 +1735,7 @@ void CalcDirectEvapCooler(EnergyPlusData &state, int EvapCoolNum, Real64 const P //*************************************************************************** // ENERGY CONSUMED BY THE RECIRCULATING PUMP - // Add the pump energy to the total Evap Cooler energy comsumption + // Add the pump energy to the total Evap Cooler energy consumption thisEvapCond.EvapCoolerPower += PartLoadRatio * thisEvapCond.RecircPumpPower; //****************** // WATER CONSUMPTION IN m3 OF WATER FOR DIRECT @@ -1839,12 +1839,12 @@ void CalcDryIndirectEvapCooler(EnergyPlusData &state, int EvapCoolNum, Real64 co CpAir = Psychrometrics::PsyCpAirFnW(thisEvapCond.InletHumRat); RhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, thisEvapCond.InletTemp, thisEvapCond.InletHumRat); CFMAir = thisEvapCond.VolFlowRate; // Volume Flow Rate Primary Side - CFMSec = thisEvapCond.IndirectVolFlowRate; // Volume Flolw Rate Secondary Side + CFMSec = thisEvapCond.IndirectVolFlowRate; // Volume Flow Rate Secondary Side QHX = EffHX * min(CFMSec, CFMAir) * RhoAir * CpAir * (thisEvapCond.InletTemp - TDBSec); thisEvapCond.OutletTemp = thisEvapCond.InletTemp - QHX / (RhoAir * CFMAir * CpAir); // This is a rough approximation of the Total Indirect Stage Efficiency for the Dry stage which - // is a 2 step process the first being teh pad efficiency and then the HX Effectiveness. I think that + // is a 2 step process the first being the pad efficiency and then the HX Effectiveness. I think that // this would mainly be used for evap sizing purposes. thisEvapCond.StageEff = SatEff * EffHX; //*************************************************************************** @@ -1870,7 +1870,7 @@ void CalcDryIndirectEvapCooler(EnergyPlusData &state, int EvapCoolNum, Real64 co // ENERGY CONSUMED BY THE RECIRCULATING PUMP // ENERGY CONSUMED BY THE RECIRCULATING PUMP - // Add the pump energy to the total Evap Cooler energy comsumption + // Add the pump energy to the total Evap Cooler energy consumption thisEvapCond.EvapCoolerPower += PartLoadRatio * thisEvapCond.IndirectRecircPumpPower; //****************** @@ -1941,7 +1941,7 @@ void CalcWetIndirectEvapCooler(EnergyPlusData &state, int EvapCoolNum, Real64 co //****************************************************************************** // INDIRECT STAGE EFFICIENCY FOR WET COIL INDIRECT EVAP COOLERS CFMAir = thisEvapCond.VolFlowRate; // Volume Flow Rate Primary Side - CFMSec = thisEvapCond.IndirectVolFlowRate; // Volume Flolw Rate Secondary Side + CFMSec = thisEvapCond.IndirectVolFlowRate; // Volume Flow Rate Secondary Side StageEff = thisEvapCond.WetCoilMaxEfficiency - min(thisEvapCond.WetCoilFlowRatio * CFMAir / CFMSec, thisEvapCond.WetCoilMaxEfficiency); @@ -1999,7 +1999,7 @@ void CalcWetIndirectEvapCooler(EnergyPlusData &state, int EvapCoolNum, Real64 co // ENERGY CONSUMED BY THE RECIRCULATING PUMP // ENERGY CONSUMED BY THE RECIRCULATING PUMP - // Add the pump energy to the total Evap Cooler energy comsumption + // Add the pump energy to the total Evap Cooler energy consumption thisEvapCond.EvapCoolerPower += PartLoadRatio * thisEvapCond.IndirectRecircPumpPower; //****************** @@ -2215,7 +2215,7 @@ void CalcIndirectResearchSpecialEvapCooler(EnergyPlusData &state, int const Evap SecVdot = TotalVolFlow - TertVdot; - if (SecVdot < 0.0) { // all tertiary/releif air e.g. econonizer wide open + if (SecVdot < 0.0) { // all tertiary/relief air e.g. economizer wide open SecVdot = 0.0; SecondaryInletDryBulbTemp = TertTemp; SecondaryInletWetBulbTemp = Psychrometrics::PsyTwbFnTdbWPb(state, TertTemp, TertHumRate, state.dataEnvrn->OutBaroPress); @@ -2250,7 +2250,7 @@ void CalcIndirectResearchSpecialEvapCooler(EnergyPlusData &state, int const Evap } } if (thisEvapCond.EvapCoolerOperationControlFlag) { - // addvanced mode: runs either in dry or wet depending on the entering conditions + // advanced mode: runs either in dry or wet depending on the entering conditions CalcIndirectResearchSpecialEvapCoolerAdvanced( state, EvapCoolNum, SecondaryInletDryBulbTemp, SecondaryInletWetBulbTemp, SecondaryInletDewPointTemp, SecondaryInletHumRatio); @@ -2292,7 +2292,7 @@ void CalcIndirectResearchSpecialEvapCooler(EnergyPlusData &state, int const Evap // ENERGY CONSUMED BY THE RECIRCULATING PUMP // ENERGY CONSUMED BY THE RECIRCULATING PUMP - // Add the pump energy to the total Evap Cooler energy comsumption + // Add the pump energy to the total Evap Cooler energy consumption thisEvapCond.EvapCoolerPower += thisEvapCond.IndirectRecircPumpPower * PartLoad * FanPLR; //*************************************************************************** @@ -2301,7 +2301,7 @@ void CalcIndirectResearchSpecialEvapCooler(EnergyPlusData &state, int const Evap thisEvapCond.OuletWetBulbTemp = Psychrometrics::PsyTwbFnTdbWPb(state, thisEvapCond.OutletTemp, thisEvapCond.InletHumRat, state.dataEnvrn->OutBaroPress); //*************************************************************************** - // CALCULATE other outlet propertiesusing PSYCH ROUTINES + // CALCULATE other outlet properties using PSYCH ROUTINES thisEvapCond.OutletHumRat = thisEvapCond.InletHumRat; thisEvapCond.OutletEnthalpy = Psychrometrics::PsyHFnTdbW(thisEvapCond.OutletTemp, thisEvapCond.OutletHumRat); @@ -2360,7 +2360,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, { // SUBROUTINE INFORMATION: - // AUTHOR B. Bigusse + // AUTHOR B. Nigusse // DATE WRITTEN October 2014 // PURPOSE OF THIS SUBROUTINE: @@ -2369,7 +2369,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, // SUBROUTINE PARAMETER DEFINITIONS: int constexpr MaxIte(500); // Maximum number of iterations for solver - Real64 constexpr TempTol(0.01); // convergence tollerance + Real64 constexpr TempTol(0.01); // convergence tolerance // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 BoundTemp; // temperature limit for outlet @@ -2423,7 +2423,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, EvapCond.SecInletMassFlowRate = AirMassFlowSec; CalcIndirectRDDEvapCoolerOutletTemp( state, EvapCoolNum, OperatingMode::DryModulated, AirMassFlowSec, InletDryBulbTempSec, InletWetBulbTempSec, InletHumRatioSec); - Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Coler outlet air temperature + Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Cooler outlet air temperature return SysTempSetPoint - OutletAirTemp; }; int SolFla = 0; // Flag of solver @@ -2489,7 +2489,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, EvapCond.SecInletMassFlowRate = AirMassFlowSec; CalcIndirectRDDEvapCoolerOutletTemp( state, EvapCoolNum, OperatingMode::DryModulated, AirMassFlowSec, InletDryBulbTempSec, InletWetBulbTempSec, InletHumRatioSec); - Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Coler outlet air temperature + Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Cooler outlet air temperature return SysTempSetPoint - OutletAirTemp; }; int SolFla = 0; // Flag of solver @@ -2548,7 +2548,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, EvapCond.SecInletMassFlowRate = AirMassFlowSec; CalcIndirectRDDEvapCoolerOutletTemp( state, EvapCoolNum, OperatingMode::WetModulated, AirMassFlowSec, InletDryBulbTempSec, InletWetBulbTempSec, InletHumRatioSec); - Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Coler outlet air temperature + Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Cooler outlet air temperature return SysTempSetPoint - OutletAirTemp; }; General::SolveRoot(state, TempTol, MaxIte, SolFla, AirMassFlowSec, f2, MassFlowRateSecMin, MassFlowRateSecMax); @@ -2624,7 +2624,7 @@ void CalcIndirectResearchSpecialEvapCoolerAdvanced(EnergyPlusData &state, EvapCond.SecInletMassFlowRate = AirMassFlowSec; CalcIndirectRDDEvapCoolerOutletTemp( state, EvapCoolNum, OperatingMode::WetModulated, AirMassFlowSec, InletDryBulbTempSec, InletWetBulbTempSec, InletHumRatioSec); - Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Coler outlet air temperature + Real64 const OutletAirTemp = EvapCond.OutletTemp; // evap Cooler outlet air temperature return SysTempSetPoint - OutletAirTemp; }; int SolFla = 0; // Flag of solver @@ -2795,7 +2795,7 @@ OperatingMode IndirectResearchSpecialEvapCoolerOperatingMode(EnergyPlusData &sta // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 InletDryBulbTempPri; // entering air dry bulb temperature of primary air Real64 SysTempSetPoint; // evaporative cooler outlet setpoint temperature, drybulb - OperatingMode OperatingMode; // current operating mode of indrect evaporative cooler + OperatingMode OperatingMode; // current operating mode of indirect evaporative cooler auto const &thisEvapCond = state.dataEvapCoolers->EvapCond(EvapCoolNum); @@ -2839,7 +2839,7 @@ void CalcIndirectRDDEvapCoolerOutletTemp(EnergyPlusData &state, // DATE WRITTEN Sep 2014 // PURPOSE OF THIS SUBROUTINE: - // Indirect research special evaporative cooler perfomance: + // Indirect research special evaporative cooler performance: // determines the IEC primary air outlet temperature // METHODOLOGY EMPLOYED: @@ -2954,7 +2954,7 @@ void CalcSecondaryAirOutletCondition(EnergyPlusData &state, // METHODOLOGY EMPLOYED: // applies energy balance equations to determine the secondary air outlet condition // For wt operations assumes the secondary air leaves at at inlet temperature, i.e., - // latent heat transfer only. For dry operation the humdity ratio remains constant. + // latent heat transfer only. For dry operation the humidity ratio remains constant. // REFERENCES: // CalculateWaterUsage routine of cooling towers for wet operation mode @@ -2963,7 +2963,7 @@ void CalcSecondaryAirOutletCondition(EnergyPlusData &state, Real64 SecOutletAirHumRat; // secondary air humidity ratio at the outlet node Real64 SecOutletEnthalpy; // secondary air outlet enthalpy Real64 CpAirSec; // specific heat of secondary air at inlet condition - Real64 hfg; // secondary air side enthaly of evaporation + Real64 hfg; // secondary air side enthalpy of evaporation auto &thisEvapCond(state.dataEvapCoolers->EvapCond(EvapCoolNum)); diff --git a/src/EnergyPlus/EvaporativeFluidCoolers.cc b/src/EnergyPlus/EvaporativeFluidCoolers.cc index 3e170a3c51e..d3627083a06 100644 --- a/src/EnergyPlus/EvaporativeFluidCoolers.cc +++ b/src/EnergyPlus/EvaporativeFluidCoolers.cc @@ -905,7 +905,7 @@ namespace EvaporativeFluidCoolers { ShowSevereError( state, format( - "{} = \"{}\". Low-Speed User Specified Design Capacity must be less than the High-Speed User Specified Design Dapacity.", + "{} = \"{}\". Low-Speed User Specified Design Capacity must be less than the High-Speed User Specified Design Capacity.", state.dataIPShortCut->cCurrentModuleObject, thisEFC.Name)); ErrorsFound = true; @@ -964,7 +964,7 @@ namespace EvaporativeFluidCoolers { "\"UFactorTimesAreaAndDesignWaterFlowRate\" or \"StandardDesignCapacity\" or \"UserSpecifiedDesignCapacity\".", state.dataIPShortCut->cCurrentModuleObject, thisEFC.Name)); - ShowContinueError(state, format("Evaporative fluid cooler Performanace Input Method currently specified as: {}", AlphArray(4))); + ShowContinueError(state, format("Evaporative fluid cooler Performance Input Method currently specified as: {}", AlphArray(4))); ErrorsFound = true; } @@ -2225,7 +2225,7 @@ namespace EvaporativeFluidCoolers { } // Calculate bypass fraction since OWTLowerLimit < OutletWaterTemp < TempSetPoint. - // The iteration ends when the numer of iteration exceeds the limit or the difference + // The iteration ends when the number of iteration exceeds the limit or the difference // between the new and old bypass fractions is less than the threshold. if (BypassFlag == 1) { Real64 bypassFraction = (TempSetPoint - this->OutletWaterTemp) / (inletWaterTemp - this->OutletWaterTemp); @@ -2254,7 +2254,7 @@ namespace EvaporativeFluidCoolers { this->SimSimpleEvapFluidCooler( state, this->WaterMassFlowRate * (1.0 - BypassFraction2), AirFlowRate, UAdesign, this->OutletWaterTemp); if (this->OutletWaterTemp < OWTLowerLimit) { - // Use previous iteraction values + // Use previous iteration values BypassFraction2 = BypassFractionPrev; this->OutletWaterTemp = OutletWaterTempPrev; } @@ -2520,7 +2520,7 @@ namespace EvaporativeFluidCoolers { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // Collect evaporative fluid cooler water useage calculations for + // Collect evaporative fluid cooler water usage calculations for // reuse by all the evaporative fluid cooler models. // REFERENCES: @@ -2657,7 +2657,7 @@ namespace EvaporativeFluidCoolers { return; // Check flow rate through evaporative fluid cooler and compare to design flow rate, - // show warning if greater than Design * Mulitplier + // show warning if greater than Design * Multiplier if (state.dataLoopNodes->Node(this->WaterOutletNode).MassFlowRate > this->DesWaterMassFlowRate * this->EvapFluidCoolerMassFlowRateMultiplier) { ++this->HighMassFlowErrorCount; diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index 1f4601b9296..0d2e0fcf4f1 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -1639,7 +1639,7 @@ void FluidCoolerspecs::size(EnergyPlusData &state) OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCApproach, this->Name, this->DesignLeavingWaterTemp - this->DesignEnteringAirWetBulbTemp); OutputReportPredefined::PreDefTableEntry( - state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // eqival to Design Fan Power? + state, state.dataOutRptPredefined->pdchCTFCDesFanPwr, this->Name, this->HighSpeedFanPower); // equivalent to Design Fan Power? OutputReportPredefined::PreDefTableEntry( state, state.dataOutRptPredefined->pdchCTFCDesInletAirWBT, this->Name, this->DesignEnteringAirWetBulbTemp); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCTFCDesWaterFlowRate, this->Name, this->DesignWaterFlowRate); @@ -1978,7 +1978,7 @@ void FluidCoolerspecs::update(EnergyPlusData &state) state.dataGlobal->WarmupFlag) return; - // Check flow rate through fluid cooler and compare to design flow rate, show warning if greater than Design * Mulitplier + // Check flow rate through fluid cooler and compare to design flow rate, show warning if greater than Design * Multiplier if (state.dataLoopNodes->Node(waterOutletNode).MassFlowRate > this->DesWaterMassFlowRate * this->FluidCoolerMassFlowRateMultiplier) { ++this->HighMassFlowErrorCount; if (this->HighMassFlowErrorCount < 2) { diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index 1d590e325e1..f900c3a695b 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -118,7 +118,7 @@ namespace Furnaces { // METHODOLOGY EMPLOYED: // Calculates the part-load ratio of the HVAC system to meet the zone sensible load. For non-heat pump HVAC systems, // if humidity control is specified and the latent capacity at the sensible PLR is insufficient to meet the latent load, - // calculate a latent part-load ratio to meet the zone sensible load (MultiMode dehumidificaiton control) or the zone + // calculate a latent part-load ratio to meet the zone sensible load (MultiMode dehumidification control) or the zone // latent load (CoolReheat dehumidification control). Use the greater of the sensible PLR and latent PLR to control // the HVAC system. // Subroutines: @@ -134,10 +134,10 @@ namespace Furnaces { // CalcNewZoneHeatCoolFlowRates - HeatCool furnace/unitarysystem and air-to-air HeatPump routine. // Calculates a part-load ratio for the system (sensible and/or latent). // For dehumidification control type COOLREHEAT, both a sensible and latent PLR - // may exist for a single time step (heating and dehumidificaiton can occur). For all + // may exist for a single time step (heating and dehumidification can occur). For all // other system types, only a single PLR is allowed for any given time step. // Order of simulation depends on dehumidification control option as described below. - // Dehumidificaiton control options (non-heat pump versions): + // Dehumidification control options (non-heat pump versions): // Dehumidification Control NONE: Cooling performance is simulated first and then heating performance. If a HX // assisted cooling coil is selected, the HX is always active (cooling). // Dehumidification Control COOLREHEAT: For cooling operation, the sensible capacity is calculated to @@ -309,7 +309,7 @@ namespace Furnaces { state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio); } } break; - // Simulate HeatCool sytems: + // Simulate HeatCool systems: case HVAC::UnitarySysType::Furnace_HeatCool: case HVAC::UnitarySysType::Unitary_HeatCool: { if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) { @@ -413,7 +413,7 @@ namespace Furnaces { // Simulate furnace reheat coil if a humidistat is used or if the reheat coil is present if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || thisFurnace.SuppHeatCoilIndex > 0) { - SuppHeatingCoilFlag = true; // if truee simulates supplemental heating coil + SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual); } } @@ -518,7 +518,7 @@ namespace Furnaces { // Simulate furnace reheat coil if a humidistat is present, the dehumidification type of coolreheat and // reheat coil load exists if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) { - SuppHeatingCoilFlag = true; // if truee simulates supplemental heating coil + SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual); } else { SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil @@ -2155,7 +2155,7 @@ namespace Furnaces { } } - } else { // Illeagal heating coil + } else { // Illegal heating coil ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1))); ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(15), Alphas(15))); ErrorsFound = true; @@ -5823,7 +5823,7 @@ namespace Furnaces { // Bo Shen, ORNL, July 2012 - added variable-speed air source heat pump cooling and heating coils, using curve-fits // PURPOSE OF THIS SUBROUTINE: - // This subroutine is for sizing Furnace Components for which nominal cpacities + // This subroutine is for sizing Furnace Components for which nominal capacities // and flow rates have not been specified in the input // METHODOLOGY EMPLOYED: @@ -6451,10 +6451,10 @@ namespace Furnaces { // the operating PLR (greater of the sensible and latent PLR) to meet the zone SENSIBLE load // (Multimode dehumidification control) or zone LATENT load (CoolReheat dehumidification control). // For dehumidification control type COOLREHEAT, both a sensible and latent PLR may exist for a - // single time step (heating and dehumidificaiton can occur). For all other sytem types, + // single time step (heating and dehumidification can occur). For all other system types, // only a single PLR is allowed for any given time step. // Order of simulation depends on dehumidification control option as described below. - // Dehumidificaiton control options: + // Dehumidification control options: // Dehumidification Control NONE: Cooling performance is simulated first and then heating performance. If a HX // assisted cooling coil is selected, the HX is always active. // Dehumidification Control COOLREHEAT: Continuous Fan Operation: @@ -6598,7 +6598,7 @@ namespace Furnaces { } SetAverageAirFlow(state, FurnaceNum, max(thisFurnace.HeatPartLoadRatio, thisFurnace.CoolPartLoadRatio), OnOffAirFlowRatio); - // if dehumidification load exists (for heat pumps) turn on the supplmental heater + // if dehumidification load exists (for heat pumps) turn on the supplemental heater if (state.dataFurnaces->HPDehumidificationLoadFlag) HumControl = true; } else { // not FirstHVACIteration // Init for heating @@ -7324,7 +7324,7 @@ namespace Furnaces { PartLoadRatio = 0.0; } // EndIf for IF(CoolCoilLoad.NE.0.0) - // Calculate the delivered capacity from the PLR caculated above + // Calculate the delivered capacity from the PLR calculated above CalcFurnaceOutput(state, FurnaceNum, FirstHVACIteration, @@ -7748,7 +7748,7 @@ namespace Furnaces { } // Calculate the reheat coil output - if (HumControl) { // HumControl = .TRUE. if a Humidistat is installed and dehumdification control type is CoolReheat + if (HumControl) { // HumControl = .TRUE. if a Humidistat is installed and dehumidification control type is CoolReheat if (thisFurnace.ZoneSequenceHeatingNum > 0) { QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum) .SequencedOutputRequiredToHeatingSP(thisFurnace.ZoneSequenceHeatingNum) / @@ -7866,7 +7866,7 @@ namespace Furnaces { Real64 ZoneSensLoadMet; // Actual zone sensible load met by heat pump (W) Real64 ZoneLatLoadMet; // Actual zone latent load met by heat pump (W) Real64 ZoneSensLoadMetFanONCompON; // Max Zone sensible load heat pump can meet (W) - Real64 ZoneLatLoadMetFanONCompON; // Max Zone latentload heat pump can meet (W) + Real64 ZoneLatLoadMetFanONCompON; // Max Zone latent load heat pump can meet (W) Real64 ZoneSensLoadMetFanONCompOFF; // control zone sensible load met using only outside air // and fan heat (no coil output) (W) Real64 ZoneLatLoadMetFanONCompOFF; // control zone Latent load met using only outside air @@ -7889,7 +7889,7 @@ namespace Furnaces { Real64 Dummy2 = 0.0; // used as dummy heat and reheat coil load Real64 OnOffAirFlowRatio = 1.0; // Ratio of compressor ON air mass flow to AVERAGE air mass flow over time step int FurnaceInletNode = thisFurnace.FurnaceInletNodeNum; - HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operting mode + HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operating mode thisFurnace.MdotFurnace = thisFurnace.DesignMassFlowRate; //*********INITIAL CALCULATIONS**************** @@ -8452,7 +8452,7 @@ namespace Furnaces { // Cooling to Heating PLR Ratio (CoolHeatPLRRat) is used to track the air mass flow rate of both the heating // and cooling coils when RH control is used and the heating coil operates longer than the cooling coil. - // When CoolPartLoadRatio/CoolHeatPLRRat is used, the PLR calculated is acutally the PLR for the heating + // When CoolPartLoadRatio/CoolHeatPLRRat is used, the PLR calculated is actually the PLR for the heating // coil (heating PLR is greater than cooling PLR), it is this PLR that determines the air mass flow rate. // When MAX(HeatPartLoadRatio,CoolPartLoadRatio) is used, only one of these values is non-zero. if (fanOp == HVAC::FanOp::Cycling) { @@ -8733,7 +8733,7 @@ namespace Furnaces { state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio); } if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || thisFurnace.SuppHeatCoilIndex > 0) { - bool SuppHeatingCoilFlag = true; // if truee simulates supplemental heating coil + bool SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual); } } // IF(Furnace(FurnaceNum)%type == UnitarySys_HeatPump_AirToAir)THEN @@ -9048,7 +9048,7 @@ namespace Furnaces { } else { state.dataFurnaces->FanSpeedRatio = state.dataFurnaces->CompOnFlowRatio; } - // IF the furnace is scheduled on or nightime cycle overrides fan schedule. Uses same logic as fan. + // IF the furnace is scheduled on or nighttime cycle overrides fan schedule. Uses same logic as fan. if (ScheduleManager::GetCurrentScheduleValue(state, state.dataFurnaces->Furnace(FurnaceNum).SchedPtr) > 0.0 && ((ScheduleManager::GetCurrentScheduleValue(state, state.dataFurnaces->Furnace(FurnaceNum).FanAvailSchedPtr) > 0.0 || state.dataHVACGlobal->TurnFansOn) && @@ -9100,7 +9100,7 @@ namespace Furnaces { } } - // Set mass flow rates during on and off cylce using an OnOff fan + // Set mass flow rates during on and off cycle using an OnOff fan if (state.afn->distribution_simulated) { state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOnMassFlowrate = state.dataFurnaces->CompOnMassFlow; state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOffMassFlowrate = state.dataFurnaces->CompOffMassFlow; @@ -9165,7 +9165,7 @@ namespace Furnaces { int CoilTypeNum(0); // heating coil type number int HeatingCoilIndex(0); // heating coil index int CoilControlNode(0); // control node for hot water and steam heating coils - int CoilOutletNode(0); // air outlet node of the heatiing coils + int CoilOutletNode(0); // air outlet node of the heating coils PlantLocation plantLoc{}; // plant loop location Real64 QActual = 0.0; // actual heating load @@ -9471,7 +9471,7 @@ namespace Furnaces { // Calculate the reheat coil output if ((ScheduleManager::GetCurrentScheduleValue(state, thisFurnace.SchedPtr) > 0.0) && (thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && - (QLatReq < 0.0))) { // if a Humidistat is installed and dehumdification control type is CoolReheat + (QLatReq < 0.0))) { // if a Humidistat is installed and dehumidification control type is CoolReheat CalcVarSpeedHeatPump(state, FurnaceNum, FirstHVACIteration, @@ -9579,9 +9579,9 @@ namespace Furnaces { if (TotBranchNum == 1) { int ZoneSideNodeNum = state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).ZoneEquipSupplyNodeNum(1); // THE MASS FLOW PRECISION of the system solver is not enough for some small air flow rate iterations , BY DEBUGGING - // it may cause mass flow rate occilations between airloop and zoneequip + // it may cause mass flow rate oscillations between airloop and zoneequip // specify the air flow rate directly for one-to-one system, when the iteration deviation is closing the solver precision level - // 0.02 is 2 * HVACFlowRateToler, in order to accomodate the system solver precision level + // 0.02 is 2 * HVACFlowRateToler, in order to accommodate the system solver precision level if (std::abs(AirMassFlow - state.dataLoopNodes->Node(ZoneSideNodeNum).MassFlowRate) < 0.02) state.dataLoopNodes->Node(ZoneSideNodeNum).MassFlowRateMaxAvail = AirMassFlow; state.dataLoopNodes->Node(ZoneSideNodeNum).MassFlowRate = AirMassFlow; @@ -10052,7 +10052,7 @@ namespace Furnaces { // DATE WRITTEN: March 2012 // PURPOSE OF THIS SUBROUTINE: - // This routine will calcultes MSHP performance based on given system load + // This routine will calculates MSHP performance based on given system load Real64 SavePartloadRatio = 0.0; // part-load ratio Real64 SaveSpeedRatio = 0.0; // speed ratio diff --git a/src/EnergyPlus/General.cc b/src/EnergyPlus/General.cc index 65a1dd95fed..9af92db3769 100644 --- a/src/EnergyPlus/General.cc +++ b/src/EnergyPlus/General.cc @@ -186,7 +186,7 @@ void SolveRoot(const EnergyPlusData &state, Real64 X0 = X_0; // present 1st bound Real64 X1 = X_1; // present 2nd bound Real64 XTemp = X0; // new estimate - int NIte = 0; // number of interations + int NIte = 0; // number of iterations int AltIte = 0; // an accounter used for Alternation choice Real64 Y0 = f(X0); // f at X0 @@ -396,7 +396,7 @@ void DetermineDateTokens(EnergyPlusData &state, static constexpr std::array SingleChars{"/", ":", "-"}; static constexpr int NumDoubleChars(6); static constexpr std::array DoubleChars{ - "ST ", "ND ", "RD ", "TH ", "OF ", "IN "}; // Need trailing spaces: Want thse only at end of words + "ST ", "ND ", "RD ", "TH ", "OF ", "IN "}; // Need trailing spaces: Want these only at end of words static constexpr std::array Months{"JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"}; static constexpr std::array Weekdays{"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"}; @@ -701,7 +701,7 @@ bool BetweenDates(int const TestDate, // Date to test // METHODOLOGY EMPLOYED: // The input dates are Julian Day format, year is irrelevant. // Thus, if StartDate > EndDate (i.e. StartDate = 1Dec and EndDate = 31Jan), - // this routine accomodates. + // this routine accommodates. // REFERENCES: // Adapted from BLAST BTWEEN function. @@ -805,7 +805,7 @@ void Iterate(Real64 &ResultX, // ResultX is the final Iteration result passed b // DATE WRITTEN March 2004 // PURPOSE OF THIS SUBROUTINE: - // Iterately solves for the value of X which satisfies Y(X)=0. + // Iteratively solves for the value of X which satisfies Y(X)=0. // The subroutine tests for convergence and provides a new guess for the value of the // independent variable X. @@ -1087,7 +1087,7 @@ void ScanForReports(EnergyPlusData &state, state.dataGeneral->SurfDetWVert = true; break; case COSTINFO: - // Custom case for reporting surface info for cost estimates (for first costs in opitimzing) + // Custom case for reporting surface info for cost estimates (for first costs in optimizing) state.dataGeneral->CostInfo = true; break; case VIEWFACTORINFO: // actual reporting is in HeatBalanceIntRadExchange diff --git a/src/EnergyPlus/GeneratorDynamicsManager.cc b/src/EnergyPlus/GeneratorDynamicsManager.cc index f20c5159d5b..b4093dde713 100644 --- a/src/EnergyPlus/GeneratorDynamicsManager.cc +++ b/src/EnergyPlus/GeneratorDynamicsManager.cc @@ -170,7 +170,7 @@ namespace GeneratorDynamicsManager { // Control decision results include: // -- electrical load allowed/resulting/provided // -- new operating mode - // -- part load this timestep for shift to normal mode occuring midway in timestep + // -- part load this timestep for shift to normal mode occurring midway in timestep // -- part load this timestep for shift out of cool down mode // Input data used to make control decisions include: @@ -527,7 +527,7 @@ namespace GeneratorDynamicsManager { newOpMode = DataGenerators::OperatingMode::Standby; } - } else { // not mandetory cool donw + } else { // not mandatory cool down // likely to go into warm up but if no warm up then back to normal if (thisGen.WarmUpByTimeDelay) { if (thisGen.StartUpTimeDelay == 0.0) { @@ -747,7 +747,7 @@ namespace GeneratorDynamicsManager { // common place to figure flow rates with internal flow control // METHODOLOGY EMPLOYED: - // apply contraints imposed by plant according to flow lock, first HVAC iteration etc. + // apply constraints imposed by plant according to flow lock, first HVAC iteration etc. // Return value Real64 FuncDetermineCWMdotForInternalFlowControl; diff --git a/src/EnergyPlus/GeneratorFuelSupply.cc b/src/EnergyPlus/GeneratorFuelSupply.cc index ebbe59af1ac..6b50f2f319e 100644 --- a/src/EnergyPlus/GeneratorFuelSupply.cc +++ b/src/EnergyPlus/GeneratorFuelSupply.cc @@ -77,7 +77,7 @@ namespace GeneratorFuelSupply { // reused among some generators to define gaseous fuel chemistry, optional compressor) // Module containing the routines dealing with the fuel supply for some generators - // different generator modules can reuse the same fuel supply code, hence a seperate module + // different generator modules can reuse the same fuel supply code, hence a separate module // MODULE INFORMATION: // AUTHOR B Griffith diff --git a/src/EnergyPlus/GroundTemperatureModeling/FiniteDifferenceGroundTemperatureModel.cc b/src/EnergyPlus/GroundTemperatureModeling/FiniteDifferenceGroundTemperatureModel.cc index 7cb4a0bb2b1..b8c1de403df 100644 --- a/src/EnergyPlus/GroundTemperatureModeling/FiniteDifferenceGroundTemperatureModel.cc +++ b/src/EnergyPlus/GroundTemperatureModeling/FiniteDifferenceGroundTemperatureModel.cc @@ -143,7 +143,7 @@ void FiniteDiffGroundTempsModel::initAndSim(EnergyPlusData &state) // DATE WRITTEN Summer 2015 // PURPOSE OF THIS SUBROUTINE: - // Initalizes and simulated finite difference ground temps model + // Initializes and simulated finite difference ground temps model FiniteDiffGroundTempsModel::getWeatherData(state); @@ -322,10 +322,10 @@ void FiniteDiffGroundTempsModel::getWeatherData(EnergyPlusData &state) } // ... End day loop. - annualAveAirTemp = annualAveAirTemp_num / state.dataWeather->NumDaysInYear; // Used for initalizing domain + annualAveAirTemp = annualAveAirTemp_num / state.dataWeather->NumDaysInYear; // Used for initializing domain - // Reset Envrionment when done reading data - --state.dataWeather->NumOfEnvrn; // May need better way of eliminating the extra envrionment that was added to read the data + // Reset Environment when done reading data + --state.dataWeather->NumOfEnvrn; // May need better way of eliminating the extra environment that was added to read the data --state.dataWeather->TotRunPers; state.dataGlobal->KindOfSim = KindOfSim_reset; state.dataWeather->RPReadAllWeatherData = false; @@ -564,7 +564,7 @@ void FiniteDiffGroundTempsModel::updateSurfaceCellTemperature(EnergyPlusData &st currAirTempK = cwd.dryBulbTemp + 273.15; // Convert input solar radiation [w/m2] into units for ET model, [MJ/hr-min] - // Diffuse + Direct Beam Radation + // Diffuse + Direct Beam Radiation incidentSolar_MJhrmin = cwd.horizontalRadiation * convert_Wm2_To_MJhrmin; // Absorbed solar radiation, [MJ/hr-min] @@ -664,7 +664,7 @@ void FiniteDiffGroundTempsModel::updateGeneralDomainCellTemperature(int const ce numerator += (thisCell.beta / resistance) * cellAbove_thisCell.temperature; denominator += thisCell.beta / resistance; - // Conduction resitance between this cell and below cell + // Conduction resistance between this cell and below cell resistance = ((thisCell.thickness / 2.0) / (thisCell.conductionArea * thisCell.props.conductivity)) + ((cellBelow_thisCell.thickness / 2.0) / (cellBelow_thisCell.conductionArea * cellBelow_thisCell.props.conductivity)); @@ -787,7 +787,7 @@ void FiniteDiffGroundTempsModel::initDomain(EnergyPlusData &state) // DATE WRITTEN Summer 2015 // PURPOSE OF THIS SUBROUTINE: - // Initalizes model using Kusuda-Achenbach model. + // Initializes model using Kusuda-Achenbach model. // Average ground temp initialized to average annual air temperature // Temporary KA model for initialization @@ -1019,7 +1019,7 @@ Real64 FiniteDiffGroundTempsModel::getGroundTempAtTimeInSeconds(EnergyPlusData & // DATE WRITTEN Summer 2015 // PURPOSE OF THIS SUBROUTINE: - // Retrieves ground tempeature when input time is in seconds + // Retrieves ground temperature when input time is in seconds depth = _depth; diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index ea4fc8c7ee4..7356955f26d 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -104,7 +104,7 @@ namespace HVACMultiSpeedHeatPump { // EnergyPlus. // Module currently models air-cooled or evap-cooled direct expansion systems - // (split or packaged) with mulptiple speeds. Air-side performance is modeled to determine + // (split or packaged) with multiple speeds. Air-side performance is modeled to determine // coil discharge air conditions. The module also determines the DX unit's energy // usage. Neither the air-side performance nor the energy usage includes the effect // of supply air fan heat/energy usage. The supply air fan is modeled by other modules. @@ -194,7 +194,7 @@ namespace HVACMultiSpeedHeatPump { int const MSHeatPumpNum, // number of the current engine driven Heat Pump being simulated bool const FirstHVACIteration, // TRUE if 1st HVAC simulation of system timestep int const AirLoopNum, // air loop index - Real64 &QSensUnitOut, // cooling/heating deliveded to zones [W] + Real64 &QSensUnitOut, // cooling/heating delivered to zones [W] Real64 const QZnReq, // required zone load Real64 &OnOffAirFlowRatio // ratio of compressor ON airflow to AVERAGE airflow over timestep ) @@ -222,7 +222,7 @@ namespace HVACMultiSpeedHeatPump { int OutletNode; // MSHP air outlet node int InletNode; // MSHP air inlet node Real64 AirMassFlow; // air mass flow rate [kg/s] - HVAC::FanOp fanOp; // operating mode (fan cycling or continious; DX coil always cycles) + HVAC::FanOp fanOp; // operating mode (fan cycling or continuous; DX coil always cycles) int ZoneNum; // Controlled zone number Real64 QTotUnitOut; int SpeedNum; // Speed number @@ -852,7 +852,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } - // Get the lemental Heating Coil Inlet Node + // Get the supplemental Heating Coil Inlet Node errFlag = false; HeatingCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag); thisMSHP.CoilAirInletNode = HeatingCoilInletNode; @@ -861,7 +861,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } - // Get the lemental Heating Coil Outlet Node + // Get the supplemental Heating Coil Outlet Node errFlag = false; HeatingCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag); if (errFlag) { @@ -895,7 +895,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } - // Get the lemental Heating Coil steam inlet node number + // Get the supplemental Heating Coil steam inlet node number errFlag = false; thisMSHP.CoilControlNode = SteamCoils::GetCoilAirOutletNode(state, "Coil:Heating:Steam", thisMSHP.HeatCoilName, errFlag); if (errFlag) { @@ -903,7 +903,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } - // Get the lemental Heating Coil steam max volume flow rate + // Get the supplemental Heating Coil steam max volume flow rate thisMSHP.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.HeatCoilNum, errFlag); if (thisMSHP.MaxCoilFluidFlow > 0.0) { SteamIndex = 0; // Function GetSatDensityRefrig will look up steam index if 0 is passed @@ -912,7 +912,7 @@ namespace HVACMultiSpeedHeatPump { thisMSHP.MaxCoilFluidFlow *= SteamDensity; } - // Get the lemental Heating Coil Inlet Node + // Get the supplemental Heating Coil Inlet Node errFlag = false; HeatingCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum, thisMSHP.HeatCoilName, errFlag); thisMSHP.CoilAirInletNode = HeatingCoilInletNode; @@ -921,7 +921,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } - // Get the lemental Heating Coil Outlet Node + // Get the supplemental Heating Coil Outlet Node errFlag = false; HeatingCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum, thisMSHP.HeatCoilName, errFlag); if (errFlag) { @@ -1288,7 +1288,7 @@ namespace HVACMultiSpeedHeatPump { ErrorsFound = true; } BranchNodeConnections::TestCompSet( - state, state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1), Alphas(16), Alphas(17), "MSHP Heat receovery Nodes"); + state, state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1), Alphas(16), Alphas(17), "MSHP Heat Recovery Nodes"); DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.DXCoolCoilIndex); if (thisMSHP.DXHeatCoilIndex > 0) { DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.DXHeatCoilIndex); @@ -2291,7 +2291,7 @@ namespace HVACMultiSpeedHeatPump { } } - // Calcuate air distribution losses + // Calculate air distribution losses if (!FirstHVACIteration && state.dataHVACMultiSpdHP->AirLoopPass == 1) { int ZoneInNode = MSHeatPump(MSHeatPumpNum).ZoneInletNode; DeltaMassRate = state.dataLoopNodes->Node(OutNode).MassFlowRate - @@ -2918,7 +2918,7 @@ namespace HVACMultiSpeedHeatPump { HVAC::CompressorOp const compressorOp, // compressor operation; 1=on, 0=off HVAC::FanOp const fanOp, // operating mode: FanOp::Cycling | FanOp::Continuous Real64 const QZnReq, // cooling or heating output needed by zone [W] - int const EMSOutput, // unit full output when compressor is operating [W]vvvv + int const EMSOutput, // unit full output when compressor is operating [W] int const SpeedNum, // Speed number Real64 SpeedRatio, // unit speed ratio for DX coils Real64 PartLoadFrac, // unit part load fraction @@ -3186,7 +3186,7 @@ namespace HVACMultiSpeedHeatPump { } } - // Coolling + // Cooling if (QZnReq < (-1.0 * HVAC::SmallLoad) && QZnReq > FullOutput) { CalcMSHeatPump( state, MSHeatPumpNum, FirstHVACIteration, compressorOp, 1, 0.0, 0.0, TempOutput0, QZnReq, OnOffAirFlowRatio, SupHeaterLoad); @@ -3605,7 +3605,7 @@ namespace HVACMultiSpeedHeatPump { // DATE WRITTEN: June 2007 // PURPOSE OF THIS SUBROUTINE: - // This routine will calcultes MSHP performance based on given system load + // This routine will calculates MSHP performance based on given system load // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int OutletNode; // MSHP air outlet node @@ -3616,7 +3616,7 @@ namespace HVACMultiSpeedHeatPump { Real64 SaveSpeedRatio; Real64 QCoilActual; // coil load actually delivered returned to calling component Real64 MinWaterFlow; // minimum water flow rate - Real64 ErrorToler; // supplemental heating coil convergence tollerance + Real64 ErrorToler; // supplemental heating coil convergence tolerance auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum); diff --git a/src/EnergyPlus/HVACSingleDuctInduc.cc b/src/EnergyPlus/HVACSingleDuctInduc.cc index 5d1ece65db0..5873947826c 100644 --- a/src/EnergyPlus/HVACSingleDuctInduc.cc +++ b/src/EnergyPlus/HVACSingleDuctInduc.cc @@ -733,11 +733,11 @@ namespace HVACSingleDuctInduc { Real64 RhoAir = state.dataEnvrn->StdRhoAir; bool ErrorsFound = false; bool IsAutoSize = false; - Real64 MaxTotAirVolFlowDes = 0.0; // Desing size maximum air volume flow for reproting + Real64 MaxTotAirVolFlowDes = 0.0; // Design size maximum air volume flow for reporting Real64 MaxTotAirVolFlowUser = 0.0; // User hard-sized maximum air volume flow for reporting - Real64 MaxVolHotWaterFlowDes = 0.0; // Desing size maximum hot water flow for reproting + Real64 MaxVolHotWaterFlowDes = 0.0; // Design size maximum hot water flow for reporting Real64 MaxVolHotWaterFlowUser = 0.0; // User hard-sized maximum hot water flow for reporting - Real64 MaxVolColdWaterFlowDes = 0.0; // Desing size maximum cold water flow for reproting + Real64 MaxVolColdWaterFlowDes = 0.0; // Design size maximum cold water flow for reporting Real64 MaxVolColdWaterFlowUser = 0.0; // User hard-sized maximum cold water flow for reporting if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow == DataSizing::AutoSize) { diff --git a/src/EnergyPlus/HWBaseboardRadiator.cc b/src/EnergyPlus/HWBaseboardRadiator.cc index c6ff41bfedc..71b50e21e26 100644 --- a/src/EnergyPlus/HWBaseboardRadiator.cc +++ b/src/EnergyPlus/HWBaseboardRadiator.cc @@ -250,7 +250,7 @@ namespace HWBaseboardRadiator { int constexpr iHeatDesignCapacityNumericNum(3); // get input index to HW baseboard heating capacity int constexpr iHeatCapacityPerFloorAreaNumericNum(1); // get input index to HW baseboard heating capacity per floor area sizing int constexpr iHeatFracOfAutosizedCapacityNumericNum( - 2); // get input index to HW baseboard heating capacity sizing as fraction of autozized heating capacity + 2); // get input index to HW baseboard heating capacity sizing as fraction of autosized heating capacity // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int BaseboardNum; // Baseboard number @@ -813,7 +813,7 @@ namespace HWBaseboardRadiator { // This subroutine initializes the baseboard units, and determines the UA values during simulation. // METHODOLOGY EMPLOYED: - // The initialization subrotines both in high temperature radiant radiator + // The initialization subroutines both in high temperature radiant radiator // and convective only baseboard radiator are combined and modified. In addition, // an UA value calculation by LMTD method is added. // The heater is assumed to be crossflow with both fluids unmixed. @@ -1173,7 +1173,7 @@ namespace HWBaseboardRadiator { BaseSizer::reportSizerOutput(state, cCMO_BBRadiator_Water, hWBaseboard.Name, "U-Factor times Area [W/C]", hWBaseboard.UA); } } else { - // if there is no heating Sizing:Plant object and autosizng was requested, issue an error message + // if there is no heating Sizing:Plant object and autosizing was requested, issue an error message if (hWBaseboard.WaterVolFlowRateMax == DataSizing::AutoSize || hWBaseboard.RatedCapacity == DataSizing::AutoSize || hWBaseboard.RatedCapacity == 0.0) { ShowSevereError(state, "Autosizing of hot water baseboard requires a heating loop Sizing:Plant object"); @@ -1246,7 +1246,7 @@ namespace HWBaseboardRadiator { // PURPOSE OF THIS SUBROUTINE: // This subroutine calculates both the convective and radiant heat transfer rate - // in a hot water baseboard heater. The heater is assumed to be crossflowwith + // in a hot water baseboard heater. The heater is assumed to be crossflow with // both fluids unmixed. The air flow is buoyancy driven and a constant airflow // and a constant airflow velocity of 0.5m/s is assumed. @@ -1391,7 +1391,7 @@ namespace HWBaseboardRadiator { // MODIFIED Aug 2007 Daeho Kang (Add the update of radiant source) // METHODOLOGY EMPLOYED: - // The update subrotines both in high temperature radiant radiator + // The update subroutines both in high temperature radiant radiator // and convective only baseboard radiator are combined and modified. // SUBROUTINE LOCAL VARIABLE DECLARATIONS: @@ -1473,7 +1473,7 @@ namespace HWBaseboardRadiator { // April 2010 Brent Griffith, max limit to protect surface temperature calcs // PURPOSE OF THIS SUBROUTINE: - // To distribute the gains from the hot water basebaord heater + // To distribute the gains from the hot water baseboard heater // as specified in the user input file. This includes distribution // of long wavelength radiant gains to surfaces and "people." diff --git a/src/EnergyPlus/HeatBalanceSurfaceManager.cc b/src/EnergyPlus/HeatBalanceSurfaceManager.cc index d121537afdd..385ca236569 100644 --- a/src/EnergyPlus/HeatBalanceSurfaceManager.cc +++ b/src/EnergyPlus/HeatBalanceSurfaceManager.cc @@ -133,7 +133,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // PURPOSE OF THIS MODULE: // To encapsulate the data and algorithms required to -// manage the simluation of the surface heat balance for the building. +// manage the simulation of the surface heat balance for the building. // REFERENCES: // The heat balance method is outlined in the "TARP Reference Manual", NIST, NBSIR 83-2655, Feb 1983. @@ -996,7 +996,7 @@ void GatherForPredefinedReport(EnergyPlusData &state) surfName, WindowShadingControlTypeNames[int(state.dataSurface->WindowShadingControl(curWSC).shadingControlType)]); - // output list of all possible shading contructions for shaded windows including those with storms + // output list of all possible shading constructions for shaded windows including those with storms std::string names; for (int construction : surface.shadedConstructionList) { if (!names.empty()) names.append("; "); @@ -2127,7 +2127,7 @@ void InitThermalAndFluxHistories(EnergyPlusData &state) for (auto &thisEnclosure : state.dataViewFactor->EnclRadInfo) { thisEnclosure.MRT = DataHeatBalance::ZoneInitialTemp; } - // Reset spaceHeatBalance even if doSpaceHeatBalance is false, beause spaceHB is used to gether zoneHB in some cases + // Reset spaceHeatBalance even if doSpaceHeatBalance is false, because spaceHB is used to gether zoneHB in some cases for (auto &thisSpaceHB : state.dataZoneTempPredictorCorrector->spaceHeatBalance) { new (&thisSpaceHB) ZoneTempPredictorCorrector::SpaceHeatBalanceData(); // Initialize the Zone Humidity Ratio here so that it is available for EMPD implementations @@ -2836,7 +2836,7 @@ void InitSolarHeatGains(EnergyPlusData &state) state.dataHeatBal->EnclSolQSDifSol(enclNum) *= state.dataViewFactor->EnclSolInfo(enclNum).solVMULT; } - // RJH - 09-12-07 commented out report varariable calcs here since they refer to old distribution method + // RJH - 09-12-07 commented out report variable calcs here since they refer to old distribution method // DO SurfNum = 1, TotSurfaces // IF (.NOT. Surface(SurfNum)%HeatTransSurf) CYCLE //!!! Following may need to be removed or changed when shelves are considered in adjacent reflection calculations @@ -3087,7 +3087,7 @@ void InitSolarHeatGains(EnergyPlusData &state) Real64 interpFac = surfShade.blind.slatAngInterpFac; Real64 AbsDiffBlind; - // For constructions, have to do interpolation wheather we have movable slats or not + // For constructions, have to do interpolation whether we have movable slats or not for (int Lay = 1; Lay <= TotGlassLay; ++Lay) { auto const &dfAbsSlatLo = constructionSh.layerSlatBlindDfAbs(Lay)[slatIdxLo]; auto const &dfAbsSlatHi = constructionSh.layerSlatBlindDfAbs(Lay)[slatIdxHi]; @@ -3172,7 +3172,7 @@ void InitSolarHeatGains(EnergyPlusData &state) } state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) = state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec; - // Need to do it this way for now beaucse of scheduled surface gains. They do work only with + // Need to do it this way for now because of scheduled surface gains. They do work only with // BSDF windows and overwriting absorbtances will work only for ordinary windows // } else if ( SurfaceWindow( SurfNum ).WindowModelType != WindowModel:: BSDF && // SurfaceWindow( SurfNum ).WindowModelType != WindowModel:: EQL && @@ -3200,7 +3200,7 @@ void InitSolarHeatGains(EnergyPlusData &state) // ABWin(Lay) = SurfWinA(SurfNum,Lay) state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) = state.dataSurface->SurfWinA(SurfNum, Lay); } else { - // Several notes about this equation. First part is accounting for duffuse solar radiation for the ground + // Several notes about this equation. First part is accounting for diffuse solar radiation for the ground // and from the sky. Second item (SurfWinA(SurfNum,Lay) * BeamSolar) is accounting for absorbed solar // radiation originating from beam on exterior side. Third item (SurfWinACFOverlap(SurfNum,Lay)) is // accounting for absorptances from beam hitting back of the window which passes through rest of exterior @@ -3229,7 +3229,7 @@ void InitSolarHeatGains(EnergyPlusData &state) for (int Lay = 1; Lay <= TotSolidLay; ++Lay) { // Absorbed window components include: // (1) beam solar radiation absorbed by all layers in the fenestration - // (2) sky and ground reflected duffuse solar radiation absorbed by all layers + // (2) sky and ground reflected diffuse solar radiation absorbed by all layers // (3) diffuse short wave incident on the inside face of the fenestration. The short wave internal sources // include light, ... state.dataHeatBalSurfMgr->AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNum).AbsDiffFrontEQL(Lay); @@ -3326,8 +3326,8 @@ void InitSolarHeatGains(EnergyPlusData &state) // (A window shade or blind, if present, is assumed to not shade the frame, so no special // treatment of frame solar needed if window has an exterior shade or blind.) if (FrArea > 0.0) { - Real64 FrIncSolarOut = BeamFaceInc; // Total solar incident on outside offrame including solar - Real64 FrIncSolarIn = 0.0; // Total solar incident on inside offrame including solar on frame projection (W/m2) + Real64 FrIncSolarOut = BeamFaceInc; // Total solar incident on outside of frame including solar + Real64 FrIncSolarIn = 0.0; // Total solar incident on inside of frame including solar on frame projection (W/m2) Real64 TransDiffGl = 0.0; // Diffuse solar transmittance if (FrProjOut > 0.0 || FrProjIn > 0.0) { Real64 BeamFrHorFaceInc = @@ -4459,7 +4459,7 @@ void InitEMSControlledSurfaceProperties(EnergyPlusData &state) // DATE WRITTEN April 2011 // PURPOSE OF THIS SUBROUTINE: - // initialize material and construction surface properties if being overriden by EMS + // initialize material and construction surface properties if being overridden by EMS // METHODOLOGY EMPLOYED: // update solar, thermal and visible absorptance values when actuated by EMS @@ -4525,7 +4525,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) // DATE WRITTEN Jan 2012 // PURPOSE OF THIS SUBROUTINE: - // change construction on surface if overriden by EMS + // change construction on surface if overridden by EMS state.dataGlobal->AnyConstrOverridesInModel = false; for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { @@ -4542,7 +4542,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) if (state.dataSurface->SurfEMSConstructionOverrideON(SurfNum) && (state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum) > 0)) { if (state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)) - .TypeIsWindow) { // okay, allways allow windows + .TypeIsWindow) { // okay, always allow windows state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) = true; state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) = true; } @@ -4568,7 +4568,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) true; if (state.dataConstruction->Construct(surface.Construction).NumHistories != state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).NumHistories) { - // thow warning, but allow + // throw warning, but allow ShowWarningError(state, "InitEMSControlledConstructions: EMS Construction State Actuator may be unrealistic, incompatible " "CTF timescales are being used."); @@ -4609,7 +4609,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) if (state.dataConstruction->Construct(surface.Construction).SourceSinkPresent) { if (!state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).SourceSinkPresent) { - // thow warning, and do not allow + // throw warning, and do not allow ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid."); ShowContinueError(state, format("Construction named = {} has internal source/sink", @@ -4640,7 +4640,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) true; if (state.dataHeatBalFiniteDiffMgr->ConstructFD(surface.Construction).TotNodes != state.dataHeatBalFiniteDiffMgr->ConstructFD(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).TotNodes) { - // thow warning, and do not allow + // throw warning, and do not allow ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid."); ShowContinueError(state, format("Construction named = {} has number of finite difference nodes ={}", @@ -4663,7 +4663,7 @@ void InitEMSControlledConstructions(EnergyPlusData &state) if (state.dataConstruction->Construct(surface.Construction).SourceSinkPresent) { if (!state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).SourceSinkPresent) { - // thow warning, and do not allow + // throw warning, and do not allow ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid."); ShowContinueError(state, format("Construction named = {} has internal source/sink", @@ -5074,7 +5074,7 @@ void UpdateThermalHistories(EnergyPlusData &state) state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum); // Heat source/sink term for radiant systems // Only HT opaq surfaces are evaluated, previous if (surface.Class == SurfaceClass::Floor || surface.Class == SurfaceClass::Wall || // surface.Class == SurfaceClass::IntMass || surface.Class == SurfaceClass::Roof || surface.Class == SurfaceClass::Door) checks are - // reduncant. + // redundant. if (construct.SourceSinkPresent) { SurfInsideFluxHistCurr += state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) * construct.CTFSourceIn[0]; } @@ -5484,7 +5484,7 @@ void CalcThermalResilience(EnergyPlusData &state) // The current formula for determining the humidex was developed by J. M. Masterton and F. A. Richardson of // Canada's Atmospheric Environment Service in 1979. // Reference: Masterson, J., and F. Richardson, 1979: Humidex, a method of quantifying human - // discomfort due to excessive heat and humidity CLI 1-79, Environment Canada, Atmosheric Environment Servic + // discomfort due to excessive heat and humidity CLI 1-79, Environment Canada, Atmospheric Environment Service // using OutputProcessor::ReqRepVars; if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) { for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { @@ -7093,7 +7093,7 @@ void CalcHeatBalanceOutsideSurf(EnergyPlusData &state, } // This ends the calculations for this surface and goes on to the next SurfNum } break; - case DataSurfaces::OtherSideCondModeledExt: { // A surface with other side conditions determined from seperate, dynamic component + case DataSurfaces::OtherSideCondModeledExt: { // A surface with other side conditions determined from separate, dynamic component // modeling that defines the "outside environment" // First, set up the outside convection coefficient and the exterior temperature // boundary condition for the surface @@ -7168,7 +7168,7 @@ void CalcHeatBalanceOutsideSurf(EnergyPlusData &state, } // Roughness index of the exterior surface Material::SurfaceRoughness RoughSurf = state.dataHeatBalSurf->SurfRoughnessExt(SurfNum); - // Thermal absoptance of the exterior surface + // Thermal absorptance of the exterior surface Real64 AbsThermSurf = state.dataHeatBalSurf->SurfAbsThermalExt(SurfNum); HMovInsul = 0; // Check for outside movable insulation @@ -9561,7 +9561,7 @@ Real64 GetSurfIncidentSolarMultiplier(EnergyPlusData &state, int SurfNum) void InitSurfacePropertyViewFactors(EnergyPlusData &state) { - // purpuse: + // purpose: // Initializes sky and ground surfaces view factors of exterior surfaces // used by SurfaceProperty:LocalEnvironment // view factors are constant hence should be set only once @@ -9698,7 +9698,7 @@ void GetGroundSurfacesTemperatureAverage(EnergyPlusData &state) void GetGroundSurfacesReflectanceAverage(EnergyPlusData &state) { - // returns ground surfaces average reflectance (dimenssionless) + // returns ground surfaces average reflectance (dimensionless) // ground reflectance viewed by a building exterior surface // ground surfaces reflectance weighed using view factors @@ -9731,7 +9731,7 @@ void GetGroundSurfacesReflectanceAverage(EnergyPlusData &state) void ReSetGroundSurfacesViewFactor(EnergyPlusData &state, int const SurfNum) { - // resets ground veiew factors based on view factors identity + // resets ground view factors based on view factors identity // the ground view factor value is set to the first element // when the ground view factor input field is blank diff --git a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc index ec365e8c315..1710c39a10c 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc @@ -806,7 +806,7 @@ void GshpSpecs::InitWatertoWaterHP(EnergyPlusData &state, state, this->reportLoadSideMassFlowRate, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum, this->LoadPlantLoc); PlantUtilities::SetComponentFlowRate( state, this->reportSourceSideMassFlowRate, this->SourceSideInletNodeNum, this->SourceSideOutletNodeNum, this->SourcePlantLoc); - // if there's no flowin one, turn the entire "heat pump off" + // if there's no flowing one, turn the entire "heat pump off" if (this->reportLoadSideMassFlowRate <= 0.0 || this->reportSourceSideMassFlowRate <= 0.0) { this->reportLoadSideMassFlowRate = 0.0; @@ -1565,7 +1565,7 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My // RE-ENGINEERED // PURPOSE OF THIS SUBROUTINE: - // This routine simulate the heat pump peformance in cooling mode + // This routine simulate the heat pump performance in cooling mode // REFERENCES: // (1) Tang,C.C.. 2005. Modeling Packaged Heat Pumps in a Quasi-Steady @@ -1731,7 +1731,7 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My // RE-ENGINEERED // PURPOSE OF THIS SUBROUTINE: - // This routine simulate the heat pump peformance in heating mode + // This routine simulate the heat pump performance in heating mode // REFERENCES: // (1) Tang,C.C.. 2005. Modeling Packaged Heat Pumps in a Quasi-Steady diff --git a/src/EnergyPlus/HeatRecovery.cc b/src/EnergyPlus/HeatRecovery.cc index 7fcd2cf1432..db5adb9c4a6 100644 --- a/src/EnergyPlus/HeatRecovery.cc +++ b/src/EnergyPlus/HeatRecovery.cc @@ -1666,7 +1666,7 @@ namespace HeatRecovery { this->Name, this->type == HVAC::HXType::AirToAir_FlatPlate ? "Flat Plate" - : (this->type == HVAC::HXType::Desiccant_Balanced ? "Dessicant Balanced" : "Generic")); + : (this->type == HVAC::HXType::Desiccant_Balanced ? "Desiccant Balanced" : "Generic")); OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchAirHRPlateOrRotary, this->Name, @@ -1689,7 +1689,7 @@ namespace HeatRecovery { void HeatExchCond::CalcAirToAirPlateHeatExch(EnergyPlusData &state, - bool const HXUnitOn, // flag to simulate heat exchager heat recovery + bool const HXUnitOn, // flag to simulate heat exchanger heat recovery ObjexxFCL::Optional_bool_const EconomizerFlag, // economizer flag pass by air loop or OA sys ObjexxFCL::Optional_bool_const HighHumCtrlFlag // high humidity control flag passed by airloop or OA sys ) @@ -1904,7 +1904,7 @@ namespace HeatRecovery { // School Advanced Ventilation Engineering Software http://www.epa.gov/iaq/schooldesign/saves.html // SUBROUTINE PARAMETER DEFINITIONS: - Real64 constexpr ErrorTol(0.001); // error tolerence + Real64 constexpr ErrorTol(0.001); // error tolerance // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int SupOutNode; @@ -2172,7 +2172,7 @@ namespace HeatRecovery { ControlFraction = 0.0; } if (this->ExchConfig == HXConfigurationType::Rotary) { - // Rotory HX's never get bypassed, rotational speed is modulated + // Rotary HX's never get bypassed, rotational speed is modulated this->SensEffectiveness *= ControlFraction; this->LatEffectiveness *= ControlFraction; } else { // HX is a plate heat exchanger, bypass air to control SA temperature @@ -2397,7 +2397,7 @@ namespace HeatRecovery { void HeatExchCond::CalcDesiccantBalancedHeatExch( EnergyPlusData &state, - bool const HXUnitOn, // flag to simulate heat exchager heat recovery + bool const HXUnitOn, // flag to simulate heat exchanger heat recovery bool const FirstHVACIteration, // First HVAC iteration flag HVAC::FanOp const fanOp, // Supply air fan operating mode (1=cycling, 2=constant) Real64 const PartLoadRatio, // Part load ratio requested of DX compressor @@ -2422,7 +2422,7 @@ namespace HeatRecovery { // METHODOLOGY EMPLOYED: // This is an empirical heat exchanger model. The model uses heat exchanger performance data to - // calculate the air temperature and humidity ratio of the leaving upply and secondary air streams. + // calculate the air temperature and humidity ratio of the leaving supply and secondary air streams. // Humidity control can enable/disable heat recovery through the use of the HXUnitOn Subroutine argument. // Using/Aliasing @@ -2859,13 +2859,13 @@ namespace HeatRecovery { this->LatEffectiveness *= Curve::CurveValue(state, this->CoolEffectLatentCurveIndex, HXAirVolFlowRatio); } } - // calculation of local variable Csup can be 0, gaurd against divide by 0. + // calculation of local variable Csup can be 0, guard against divide by 0. TempSupOut = TempSupIn + this->SensEffectiveness * SafeDiv(CMin, CSup) * (TempSecIn - TempSupIn); QSensTrans = CSup * (TempSupIn - TempSupOut); // Csec cannot be 0 in this subroutine TempSecOut = TempSecIn + QSensTrans / CSec; Error = (TempSecOut - TempThreshold); - // recalculate DFFraction until convergence, gaurd against divide by 0 (unlikely). + // recalculate DFFraction until convergence, guard against divide by 0 (unlikely). DFFraction = max(0.0, min(1.0, DFFraction * SafeDiv((TempSecIn - TempSecOut), (TempSecIn - TempThreshold)))); ++Iter; } @@ -3303,7 +3303,7 @@ namespace HeatRecovery { // PURPOSE OF THIS SUBROUTINE: // To verify that the empirical model's independent variables are within the limits used during the - // developement of the empirical model. + // development of the empirical model. // METHODOLOGY EMPLOYED: // The empirical models used for simulating a desiccant enhanced cooling coil are based on a limited data set. @@ -3404,7 +3404,7 @@ namespace HeatRecovery { ShowContinueError(state, state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).T_ProcInHumRatError.buffer2); ShowContinueError(state, state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).T_ProcInHumRatError.buffer3); ShowContinueError(state, - "...Using process inlet air humidity ratios that are outside the regeneratoin outlet air temperature equation " + "...Using process inlet air humidity ratios that are outside the regeneration outlet air temperature equation " "model boundaries may adversely affect desiccant model performance."); } else { ShowRecurringWarningErrorAtEnd(state, @@ -3444,7 +3444,7 @@ namespace HeatRecovery { thisError.TimeStepSysLast = TimeStepSys; thisError.CurrentEndTimeLast = thisError.CurrentEndTime; - // If regen and procees inlet temperatures are the same the coil is off, do not print out of bounds warning for this case + // If regen and process inlet temperatures are the same the coil is off, do not print out of bounds warning for this case if (std::abs(T_RegenInTemp - T_ProcInTemp) < SMALL) { state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).T_RegenInTempError.print = false; state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).T_RegenInHumRatError.print = false; @@ -3667,7 +3667,7 @@ namespace HeatRecovery { // PURPOSE OF THIS SUBROUTINE: // To verify that the empirical model's independent variables are within the limits used during the - // developement of the empirical model. + // development of the empirical model. // METHODOLOGY EMPLOYED: // The empirical models used for simulating a desiccant enhanced cooling coil are based on a limited data set. @@ -3807,7 +3807,7 @@ namespace HeatRecovery { thisError.TimeStepSysLast = TimeStepSys; thisError.CurrentEndTimeLast = thisError.CurrentEndTime; - // If regen and procees inlet temperatures are the same the coil is off, do not print out of bounds warning for this case + // If regen and process inlet temperatures are the same the coil is off, do not print out of bounds warning for this case if (std::abs(H_RegenInTemp - H_ProcInTemp) < SMALL) { state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).H_RegenInTempError.print = false; state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).H_RegenInHumRatError.print = false; @@ -4031,7 +4031,7 @@ namespace HeatRecovery { // PURPOSE OF THIS SUBROUTINE: // To verify that the empirical model's independent variables are within the limits used during the - // developement of the empirical model. + // development of the empirical model. // METHODOLOGY EMPLOYED: // The empirical models used for simulating a desiccant enhanced cooling coil are based on a limited data set. @@ -4192,7 +4192,7 @@ namespace HeatRecovery { // PURPOSE OF THIS SUBROUTINE: // To verify that the empirical model's independent variables are within the limits used during the - // developement of the empirical model. + // development of the empirical model. // METHODOLOGY EMPLOYED: // The empirical models used for simulating a desiccant enhanced cooling coil are based on a limited data set. @@ -4462,7 +4462,7 @@ namespace HeatRecovery { return; } - // If regen and procees inlet temperatures are the same the coil is off, do not print out of bounds warning for this case + // If regen and process inlet temperatures are the same the coil is off, do not print out of bounds warning for this case if (std::abs(T_RegenInTemp - T_ProcInTemp) < SMALL) { state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).regenInRelHumTempErr.print = false; state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).procInRelHumTempErr.print = false; @@ -4638,7 +4638,7 @@ namespace HeatRecovery { return; } - // If regen and procees inlet temperatures are the same the coil is off, do not print out of bounds warning for this case + // If regen and process inlet temperatures are the same the coil is off, do not print out of bounds warning for this case if (std::abs(H_RegenInTemp - H_ProcInTemp) < SMALL) { state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).regenInRelHumHumRatErr.print = false; state.dataHeatRecovery->BalDesDehumPerfData(this->PerfDataIndex).procInRelHumHumRatErr.print = false; @@ -4927,7 +4927,7 @@ namespace HeatRecovery { // RE-ENGINEERED na // PURPOSE OF THIS FUNCTION: - // This function looks up the given Generic HX and the voluetric air flow rate. + // This function looks up the given Generic HX and the volumetric air flow rate. // If incorrect HX name is given, ErrorsFound is returned as true and air flow rate as zero. // Obtains and Allocates heat exchanger related parameters from input file @@ -4960,7 +4960,7 @@ namespace HeatRecovery { // RE-ENGINEERED na // PURPOSE OF THIS FUNCTION: - // This function looks up the given Generic HX and the voluetric air flow rate. + // This function looks up the given Generic HX and the volumetric air flow rate. // If incorrect HX name is given, ErrorsFound is returned as true and air flow rate as zero. // Obtains and Allocates heat exchanger related parameters from input file diff --git a/src/EnergyPlus/HighTempRadiantSystem.cc b/src/EnergyPlus/HighTempRadiantSystem.cc index 245b5ea1acd..8f078b1b625 100644 --- a/src/EnergyPlus/HighTempRadiantSystem.cc +++ b/src/EnergyPlus/HighTempRadiantSystem.cc @@ -216,7 +216,7 @@ namespace HighTempRadiantSystem { int constexpr iHeatCAPMAlphaNum = 4; // get input index to High Temperature Radiant system heating capacity sizing method int constexpr iHeatDesignCapacityNumericNum = 1; // get input index to High Temperature Radiant system heating capacity int constexpr iHeatCapacityPerFloorAreaNumericNum = 2; // index to High Temperature Radiant system heating capacity per floor area sizing - int constexpr iHeatFracOfAutosizedCapacityNumericNum = 3; // index to system capacity sizing as fraction of autozized heating capacity + int constexpr iHeatFracOfAutosizedCapacityNumericNum = 3; // index to system capacity sizing as fraction of autosized heating capacity // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 FracOfRadPotentiallyLost; // Difference between unity and AllFracsSummed for error reporting @@ -650,7 +650,7 @@ namespace HighTempRadiantSystem { } if (!state.dataGlobal->SysSizingCalc && state.dataHighTempRadSys->MySizeFlag(RadSysNum)) { - // for each radiant systen do the sizing once. + // for each radiant system do the sizing once. SizeHighTempRadiantSystem(state, RadSysNum); state.dataHighTempRadSys->MySizeFlag(RadSysNum) = false; } diff --git a/src/EnergyPlus/HybridEvapCoolingModel.cc b/src/EnergyPlus/HybridEvapCoolingModel.cc index 43fc5c8108d..7ca62778f6c 100644 --- a/src/EnergyPlus/HybridEvapCoolingModel.cc +++ b/src/EnergyPlus/HybridEvapCoolingModel.cc @@ -126,7 +126,7 @@ namespace HybridEvapCoolingModel { bool CMode::InitializeOutdoorAirHumidityRatioConstraints(Real64 min, Real64 max) { // minimum 0.00 maximum 0.10, units kgWater / kgDryAir - // note Mode0 will not be considerd when outside air absolute humidity is below the value in this field. + // note Mode0 will not be considered when outside air absolute humidity is below the value in this field. // note If this field is blank, the lower constraint on outside air humidity ratio will be 0.00 kgWater / kgDryAir., default 0.00 // the upper constraint on outside air humidity ratio will be 0.10 kgWater / kgDryAir, default 0.10 Minimum_Outdoor_Air_Humidity_Ratio = min; @@ -154,7 +154,7 @@ namespace HybridEvapCoolingModel { bool CMode::InitializeReturnAirHumidityRatioConstraints(Real64 min, Real64 max) { // minimum 0.00 maximum 0.10, units kgWater / kgDryAir - // note Mode0 will not be considerd when outside air absolute humidity is below the value in this field. + // note Mode0 will not be considered when outside air absolute humidity is below the value in this field. // note If this field is blank, the lower constraint on outside air humidity ratio will be 0.00 kgWater / kgDryAir., default 0.00 // the upper constraint on outside air humidity ratio will be 0.10 kgWater / kgDryAir, default 0.10 Minimum_Return_Air_Humidity_Ratio = min; @@ -425,7 +425,7 @@ namespace HybridEvapCoolingModel { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // Does the processing of each of the seperate modes + // Does the processing of each of the separate modes // METHODOLOGY EMPLOYED: // As the number of modes defined in the idf is not known until its read in, this method uses two counters to keep track of the inputs in the @@ -722,7 +722,7 @@ namespace HybridEvapCoolingModel { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // To check to see if this this particular setting (combination of mode, OSAF and Msa) meets the required minumum + // To check to see if this this particular setting (combination of mode, OSAF and Msa) meets the required minimum // supply air temperature specified in the schedules // METHODOLOGY EMPLOYED: @@ -753,7 +753,7 @@ namespace HybridEvapCoolingModel { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // To check to see if this this particular setting (combination of mode, OSAF and Msa) meets the required minumum + // To check to see if this this particular setting (combination of mode, OSAF and Msa) meets the required minimum // supply air relative humidity specified in the schedules // METHODOLOGY EMPLOYED: @@ -786,8 +786,8 @@ namespace HybridEvapCoolingModel { SystemLatentHeatingRate(0.0), SystemLatentHeatingEnergy(0.0), SupplyFanElectricPower(0.0), SupplyFanElectricEnergy(0.0), SecondaryFuelConsumptionRate(0.0), SecondaryFuelConsumption(0.0), ThirdFuelConsumptionRate(0.0), ThirdFuelConsumption(0.0), WaterConsumptionRate(0.0), WaterConsumption(0.0), QSensZoneOut(0), QLatentZoneOut(0), QLatentZoneOutMass(0), ExternalStaticPressure(0.0), - RequestedHumdificationMass(0.0), RequestedHumdificationLoad(0.0), RequestedHumdificationEnergy(0.0), RequestedDeHumdificationMass(0.0), - RequestedDeHumdificationLoad(0.0), RequestedDeHumdificationEnergy(0.0), RequestedLoadToHeatingSetpoint(0.0), + RequestedHumidificationMass(0.0), RequestedHumidificationLoad(0.0), RequestedHumidificationEnergy(0.0), RequestedDeHumidificationMass(0.0), + RequestedDeHumidificationLoad(0.0), RequestedDeHumidificationEnergy(0.0), RequestedLoadToHeatingSetpoint(0.0), RequestedLoadToCoolingSetpoint(0.0), TsaMin_schedule_pointer(0), TsaMax_schedule_pointer(0), RHsaMin_schedule_pointer(0), RHsaMax_schedule_pointer(0), PrimaryMode(0), PrimaryModeRuntimeFraction(0.0), averageOSAF(0), ErrorCode(0), InletNode(0), OutletNode(0), SecondaryInletNode(0), SecondaryOutletNode(0), FinalElectricalPower(0.0), FinalElectricalEnergy(0.0), InletMassFlowRate(0.0), @@ -991,7 +991,7 @@ namespace HybridEvapCoolingModel { // METHODOLOGY EMPLOYED: // For longer simulation timesteps this model can consider partial runtime fractions - // operating in different settings for a fraction of the total simulation time step reducing the likelyhood of over conditioning. + // operating in different settings for a fraction of the total simulation time step reducing the likelihood of over conditioning. // Intensive variables that do not depend on system size (like temperature, pressure,etc), and extensive variables (variable whose values // depend on the quantity of substance) are handled differently // @@ -1000,7 +1000,7 @@ namespace HybridEvapCoolingModel { // resultant time step average mass flow rate would be 1 kg/s. // Intensive values in each part runtime fraction are first multiplied by the Scaled Supply Air Mass Flow Rate for each setting - // and then once all the various runtime fractions are added up, the resultant is divided by the overal time step average Scaled Supply Air + // and then once all the various runtime fractions are added up, the resultant is divided by the overall time step average Scaled Supply Air // Mass Flow Rate // // REFERENCES: @@ -1199,14 +1199,14 @@ namespace HybridEvapCoolingModel { // -> settings that do are stored in the a container (Settings) // 3) Iterate through all the settings in Settings // - // 4) Calculate the setting zone sensible cooling and heating load and humidifcation and dehumidifcation. + // 4) Calculate the setting zone sensible cooling and heating load and humidification and dehumidification. // 5) Test to see if conditioning and humidification loads are met. // 6) Calculate setting power consumption, use the setting delivered ventilation and loads to calculate the // 7) minimum runtime fraction needed to meet those loads, then assuming that part runtime fraction calculate the setting part run time power // use. 8) If the setting meets both the conditioning and humidification loads then test to see if its optimal in terms of energy use. // ->if so, save that setting as the current optimal. // ->if not ignore it. - // If the setting failed ot meet either the conditioning or humidification loads, then + // If the setting failed to meet either the conditioning or humidification loads, then // -> firstly check to see if no previous other setting (in this calculation step) has met both the load and humidification requirements // -> if so // -> check if this setting meets the conditioning load (only) @@ -1224,7 +1224,7 @@ namespace HybridEvapCoolingModel { // -> if so: then ignore it. // ->if not, then a previous setting is better than this one by default, and so ignore it. // 9) Identify error states if the no setting meets the environmental conditions, or the supply air humidity or temperature constraints. - // 10) if we met the load set operating settings to be a combination of the optimal setting at the minium required runtime fraction + // 10) if we met the load set operating settings to be a combination of the optimal setting at the minimum required runtime fraction // 11) if we partly met the load then do the best we can and run full out in that optimal setting. // 12) if we didn't even partially meet the load make sure the operational settings are just the standby mode. // 13) generate summary statistics for warnings. @@ -1483,12 +1483,12 @@ namespace HybridEvapCoolingModel { bool Humidification_load_met = false; - Real64 RequestedDeHumdificationLoad = StepIns.ZoneDehumidificationLoad; - if (DehumidificationRequested && latentRoomORZone > RequestedDeHumdificationLoad) { + Real64 RequestedDeHumidificationLoad = StepIns.ZoneDehumidificationLoad; + if (DehumidificationRequested && latentRoomORZone > RequestedDeHumidificationLoad) { Humidification_load_met = true; } - Real64 RequestedHumdificationLoad = StepIns.ZoneMoistureLoad; - if (HumidificationRequested && latentRoomORZone < RequestedHumdificationLoad) { + Real64 RequestedHumidificationLoad = StepIns.ZoneMoistureLoad; + if (HumidificationRequested && latentRoomORZone < RequestedHumidificationLoad) { Humidification_load_met = true; } @@ -1581,7 +1581,7 @@ namespace HybridEvapCoolingModel { count_SAT_OC_MetOnce++; ErrorCode = 3; } - // if we met the load set operating settings to be a combination of the optimal setting at the minium required runtime fraction + // if we met the load set operating settings to be a combination of the optimal setting at the minimum required runtime fraction if (DidWeMeetLoad) { // add first setting to operating modes ErrorCode = 0; @@ -1677,7 +1677,7 @@ namespace HybridEvapCoolingModel { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // retunrs the primary mode of operation + // returns the primary mode of operation // METHODOLOGY EMPLOYED: // @@ -1724,7 +1724,7 @@ namespace HybridEvapCoolingModel { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // Sets member boolean variables to establish if the Cooling, Heating, ventilation or dehumidifcation needs are met. + // Sets member boolean variables to establish if the Cooling, Heating, ventilation or dehumidification needs are met. // METHODOLOGY EMPLOYED: // @@ -1764,7 +1764,7 @@ namespace HybridEvapCoolingModel { // doStep is passed some variables that could have just used the class members, but this adds clarity about whats needed, especially helpful in // unit testing void Model::doStep(EnergyPlusData &state, - Real64 RequestedCoolingLoad, // in joules, cooling load as negitive + Real64 RequestedCoolingLoad, // in joules, cooling load as negative Real64 RequestedHeatingLoad, // in joules, heating load as positive Real64 OutputRequiredToHumidify, // Load required to meet humidifying setpoint (>0 = a humidify load) [kgWater/s] Real64 OutputRequiredToDehumidify, // Load required to meet dehumidifying setpoint (<0 = a dehumidify load) [kgWater/s] @@ -1785,7 +1785,7 @@ namespace HybridEvapCoolingModel { // CoolingRequested, HeatingRequested, VentilationRequested, DehumidificationRequested, HumidificationRequested // 4)Take the first operating mode which is always standby and calculate the use curves to determine performance metrics for // the standby mode including energy use and other outputs - // 5)Test system availbility status and go into standby if unit is off or not needed (booleans listed in 3 are all false) + // 5)Test system availability status and go into standby if unit is off or not needed (booleans listed in 3 are all false) // 6) Set the operating conditions and respective part load fractions. // 7) Set timestep average outlet condition, considering all operating conditions and runtimes. // METHODOLOGY EMPLOYED: @@ -1798,13 +1798,13 @@ namespace HybridEvapCoolingModel { RequestedLoadToHeatingSetpoint = RequestedHeatingLoad; RequestedLoadToCoolingSetpoint = RequestedCoolingLoad; Real64 LambdaRa = Psychrometrics::PsyHfgAirFnWTdb(0, InletTemp); - RequestedHumdificationMass = OutputRequiredToHumidify; - RequestedHumdificationLoad = OutputRequiredToHumidify * LambdaRa; // [W]; - RequestedHumdificationEnergy = OutputRequiredToHumidify * LambdaRa * state.dataHVACGlobal->TimeStepSysSec; // [j] + RequestedHumidificationMass = OutputRequiredToHumidify; + RequestedHumidificationLoad = OutputRequiredToHumidify * LambdaRa; // [W]; + RequestedHumidificationEnergy = OutputRequiredToHumidify * LambdaRa * state.dataHVACGlobal->TimeStepSysSec; // [j] - RequestedDeHumdificationMass = OutputRequiredToDehumidify; - RequestedDeHumdificationLoad = OutputRequiredToDehumidify * LambdaRa; // [W]; - RequestedDeHumdificationEnergy = OutputRequiredToDehumidify * LambdaRa * state.dataHVACGlobal->TimeStepSysSec; // [j] + RequestedDeHumidificationMass = OutputRequiredToDehumidify; + RequestedDeHumidificationLoad = OutputRequiredToDehumidify * LambdaRa; // [W]; + RequestedDeHumidificationEnergy = OutputRequiredToDehumidify * LambdaRa * state.dataHVACGlobal->TimeStepSysSec; // [j] MinOA_Msa = DesignMinVR; // as mass flow kg/s @@ -1819,8 +1819,8 @@ namespace HybridEvapCoolingModel { StepIns.RequestedCoolingLoad = -RequestedCoolingLoad; // Cooling positive now, heating negative StepIns.RequestedHeatingLoad = -RequestedHeatingLoad; // Cooling positive now, heating negative - StepIns.ZoneMoistureLoad = RequestedHumdificationLoad; - StepIns.ZoneDehumidificationLoad = RequestedDeHumdificationLoad; + StepIns.ZoneMoistureLoad = RequestedHumidificationLoad; + StepIns.ZoneDehumidificationLoad = RequestedDeHumidificationLoad; StepIns.MinimumOA = DesignMinVR; // calculate W humidity ratios for outdoor air and return air Real64 Wosa = PsyWFnTdbRhPb(state, StepIns.Tosa, StepIns.RHosa, state.dataEnvrn->OutBaroPress); @@ -1835,7 +1835,7 @@ namespace HybridEvapCoolingModel { if (SetStandByMode(state, Mode, StepIns.Tosa, Wosa, StepIns.Tra, Wra)) { std::string ObjectID = Name.c_str(); ShowSevereError(state, - format("Standby mode not defined correctly, as the mode is defined there are zero combinations of acceptible outside air " + format("Standby mode not defined correctly, as the mode is defined there are zero combinations of acceptable outside air " "fractions and supply air mass flow rate, called in object {}", ObjectID)); } @@ -1876,7 +1876,7 @@ namespace HybridEvapCoolingModel { Real64 QSensSystemOut = 0; Real64 QLatentSystemOut = 0; // Even if its off or in standby we still need to continue to calculate standby loads - // All powers are calculated in Watts amd energies in Joules + // All powers are calculated in Watts and energies in Joules SupplyVentilationVolume = CalculateTimeStepAverage(SYSTEMOUTPUTS::VENTILATION_AIR_V); if (state.dataEnvrn->StdRhoAir > 1) { diff --git a/src/EnergyPlus/HybridModel.cc b/src/EnergyPlus/HybridModel.cc index 48e06543b2a..d7af89dd11f 100644 --- a/src/EnergyPlus/HybridModel.cc +++ b/src/EnergyPlus/HybridModel.cc @@ -139,15 +139,15 @@ namespace HybridModel { int PeopleRadiantFractionSchPtr = GetScheduleIndex(state, cAlphaArgs(11)); int PeopleCO2GenRateSchPtr = GetScheduleIndex(state, cAlphaArgs(12)); - // Pointers used to help decide wheather to include system supply terms in the inverse algorithms + // Pointers used to help decide whether to include system supply terms in the inverse algorithms int SupplyAirTemperatureSchPtr = GetScheduleIndex(state, cAlphaArgs(13)); int SupplyAirMassFlowRateSchPtr = GetScheduleIndex(state, cAlphaArgs(14)); int SupplyAirHumidityRatioSchPtr = GetScheduleIndex(state, cAlphaArgs(15)); int SupplyAirCO2ConcentrationSchPtr = GetScheduleIndex(state, cAlphaArgs(16)); // Note: Internal thermal mass can be calculated only with measured temperature. - // Air infiltration rate can be calculated with either measured temperature, humifity ratio, or CO2 - // concentration. People count can be calculated with either measured temperature, humifity ratio, or CO2 + // Air infiltration rate can be calculated with either measured temperature, humidity ratio, or CO2 + // concentration. People count can be calculated with either measured temperature, humidity ratio, or CO2 // concentration. // Initially set all flags to be false @@ -175,7 +175,7 @@ namespace HybridModel { } if (TemperatureSchPtr == 0) { - ShowSevereError(state, format("Measured Zone Air Tempearture Schedule is not defined for: {}", CurrentModuleObject)); + ShowSevereError(state, format("Measured Zone Air Temperature Schedule is not defined for: {}", CurrentModuleObject)); ErrorsFound = true; } else { state.dataHybridModel->HybridModelZone(ZonePtr).InternalThermalMassCalc_T = true; @@ -191,7 +191,7 @@ namespace HybridModel { } if (TemperatureSchPtr == 0 && HumidityRatioSchPtr == 0 && CO2ConcentrationSchPtr == 0) { // Show fatal error if no measurement schedule is provided - ShowSevereError(state, format("No measured envrionmental parameter is provided for: {}", CurrentModuleObject)); + ShowSevereError(state, format("No measured environmental parameter is provided for: {}", CurrentModuleObject)); ShowContinueError(state, format("One of the field \"{}\", \"{}\", or {}\" must be provided for the HybridModel:Zone.", cAlphaFieldNames(6), @@ -200,7 +200,7 @@ namespace HybridModel { ErrorsFound = true; } else { if (TemperatureSchPtr > 0 && !state.dataHybridModel->FlagHybridModel_TM) { - // Temperature schedule is provided, igonore humidity ratio and CO2 concentration schedules. + // Temperature schedule is provided, ignore humidity ratio and CO2 concentration schedules. state.dataHybridModel->HybridModelZone(ZonePtr).InfiltrationCalc_T = true; if (HumidityRatioSchPtr > 0) { ShowWarningError(state, format("Field \"{}\" is provided.", cAlphaFieldNames(6))); @@ -230,7 +230,7 @@ namespace HybridModel { if (state.dataHybridModel->FlagHybridModel_PC) { if (TemperatureSchPtr == 0 && HumidityRatioSchPtr == 0 && CO2ConcentrationSchPtr == 0) { // Show fatal error if no measurement schedule is provided - ShowSevereError(state, format("No measured envrionmental parameter is provided for: {}", CurrentModuleObject)); + ShowSevereError(state, format("No measured environmental parameter is provided for: {}", CurrentModuleObject)); ShowContinueError(state, format("One of the field \"{}\", \"{}\", or {}\" must be provided for the HybridModel:Zone.", cAlphaFieldNames(6), @@ -239,17 +239,17 @@ namespace HybridModel { ErrorsFound = true; } else { if (TemperatureSchPtr > 0 && !state.dataHybridModel->FlagHybridModel_TM) { - // Temperature schedule is provided, igonore humidity ratio and CO2 concentration schedules. + // Temperature schedule is provided, ignore humidity ratio and CO2 concentration schedules. state.dataHybridModel->HybridModelZone(ZonePtr).PeopleCountCalc_T = true; if (HumidityRatioSchPtr > 0) { ShowWarningError( state, - "The meausured air humidity ratio schedule will not be used since measured air temperature is provided."); + "The measured air humidity ratio schedule will not be used since measured air temperature is provided."); } if (CO2ConcentrationSchPtr > 0) { ShowWarningError( state, - "The meausured air CO2 concentration schedule will not be used since measured air temperature is provided."); + "The measured air CO2 concentration schedule will not be used since measured air temperature is provided."); } } if (HumidityRatioSchPtr > 0 && TemperatureSchPtr == 0) { @@ -257,7 +257,7 @@ namespace HybridModel { state.dataHybridModel->HybridModelZone(ZonePtr).PeopleCountCalc_H = true; if (CO2ConcentrationSchPtr > 0) { ShowWarningError(state, - "The meausured air CO2 concentration schedule will not be used since measured air humidity " + "The measured air CO2 concentration schedule will not be used since measured air humidity " "ratio is provided."); } } @@ -275,7 +275,7 @@ namespace HybridModel { state.dataHybridModel->HybridModelZone(ZonePtr).IncludeSystemSupplyParameters = true; } else { ShowWarningError(state, - format("Field \"{}\", {}, and \"{}\" will not be used in the inverse balance euqation.", + format("Field \"{}\", {}, and \"{}\" will not be used in the inverse balance equation.", cAlphaFieldNames(13), cAlphaFieldNames(14), cAlphaFieldNames(15))); @@ -288,7 +288,7 @@ namespace HybridModel { state.dataHybridModel->HybridModelZone(ZonePtr).IncludeSystemSupplyParameters = true; } else { ShowWarningError(state, - format("Field \"{}\" and \"{}\" will not be used in the inverse balance euqation.", + format("Field \"{}\" and \"{}\" will not be used in the inverse balance equation.", cAlphaFieldNames(15), cAlphaFieldNames(14))); } @@ -300,7 +300,7 @@ namespace HybridModel { state.dataHybridModel->HybridModelZone(ZonePtr).IncludeSystemSupplyParameters = true; } else { ShowWarningError(state, - format("Field \"{}\" and \"{}\" will not be used in the inverse balance euqation.", + format("Field \"{}\" and \"{}\" will not be used in the inverse balance equation.", cAlphaFieldNames(16), cAlphaFieldNames(14))); } diff --git a/src/EnergyPlus/HybridUnitaryAirConditioners.cc b/src/EnergyPlus/HybridUnitaryAirConditioners.cc index 26f24c4997d..99068b1b2e1 100644 --- a/src/EnergyPlus/HybridUnitaryAirConditioners.cc +++ b/src/EnergyPlus/HybridUnitaryAirConditioners.cc @@ -200,12 +200,12 @@ void InitZoneHybridUnitaryAirConditioners(EnergyPlusData &state, } state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedLoadToHeatingSetpoint = 0; state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedLoadToCoolingSetpoint = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationMass = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationLoad = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationEnergy = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationMass = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationLoad = 0; - state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationEnergy = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumidificationMass = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumidificationLoad = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumidificationEnergy = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumidificationMass = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumidificationLoad = 0; + state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumidificationEnergy = 0; state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitTotalCoolingRate = 0.0; state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitTotalCoolingEnergy = 0.0; @@ -325,7 +325,7 @@ void InitZoneHybridUnitaryAirConditioners(EnergyPlusData &state, void CalcZoneHybridUnitaryAirConditioners(EnergyPlusData &state, int const UnitNum, // unit number int const ZoneNum, // number of zone being served - Real64 &SensibleOutputProvided, // sensible capacity delivered to zone cooling negitive + Real64 &SensibleOutputProvided, // sensible capacity delivered to zone cooling negative Real64 &LatentOutputProvided // Latent add/removal (kg/s), dehumid = negative ) { @@ -354,7 +354,7 @@ void CalcZoneHybridUnitaryAirConditioners(EnergyPlusData &state, SensibleOutputProvided = 0; LatentOutputProvided = 0; - // taking class members out of the object and then using them in the calcualtion is odd but its for clarity with unit testing. + // taking class members out of the object and then using them in the calculation is odd but its for clarity with unit testing. EnvDryBulbT = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp; // degrees C AirTempRoom = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp; // degrees C EnvRelHumm = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletRH; // RH @@ -1117,21 +1117,21 @@ void GetInputZoneHybridUnitaryAirConditioners(EnergyPlusData &state, bool &Error SetupOutputVariable(state, "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Moisture Transfer Rate", Constant::Units::kg_s, - hybridUnitaryAC.RequestedDeHumdificationMass, + hybridUnitaryAC.RequestedDeHumidificationMass, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); SetupOutputVariable(state, "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Heat Transfer Rate", Constant::Units::W, - hybridUnitaryAC.RequestedDeHumdificationLoad, + hybridUnitaryAC.RequestedDeHumidificationLoad, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); SetupOutputVariable(state, - "Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Tansfer Energy", + "Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Transfer Energy", Constant::Units::J, - hybridUnitaryAC.RequestedDeHumdificationEnergy, + hybridUnitaryAC.RequestedDeHumidificationEnergy, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); @@ -1139,21 +1139,21 @@ void GetInputZoneHybridUnitaryAirConditioners(EnergyPlusData &state, bool &Error SetupOutputVariable(state, "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Moisture Transfer Rate", Constant::Units::kg_s, - hybridUnitaryAC.RequestedHumdificationMass, + hybridUnitaryAC.RequestedHumidificationMass, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); SetupOutputVariable(state, "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Transfer Rate", Constant::Units::W, - hybridUnitaryAC.RequestedHumdificationLoad, + hybridUnitaryAC.RequestedHumidificationLoad, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); SetupOutputVariable(state, - "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Tansfer Energy", + "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Transfer Energy", Constant::Units::J, - hybridUnitaryAC.RequestedHumdificationEnergy, + hybridUnitaryAC.RequestedHumidificationEnergy, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); diff --git a/src/EnergyPlus/InternalHeatGains.cc b/src/EnergyPlus/InternalHeatGains.cc index d6d7315043e..9badf70d1b3 100644 --- a/src/EnergyPlus/InternalHeatGains.cc +++ b/src/EnergyPlus/InternalHeatGains.cc @@ -256,7 +256,7 @@ namespace InternalHeatGains { const std::string bbModuleObject = "ZoneBaseboard:OutdoorTemperatureControlled"; const std::string contamSSModuleObject = "ZoneContaminantSourceAndSink:CarbonDioxide"; - // Because there are occassions where getObjectItem will be called a second time within the routine (#9680) + // Because there are occasions where getObjectItem will be called a second time within the routine (#9680) // We should use local arrays instead of state.dataIPShortCut int IHGNumAlphas = 0; int IHGNumNumbers = 0; @@ -3334,7 +3334,7 @@ namespace InternalHeatGains { if (thisZoneITEq.FlowControlWithApproachTemps) { Real64 TAirInSizing = 0.0; - // Set the TAirInSizing to the maximun setpoint value to do sizing based on the maximum fan and cpu power of the ite + // Set the TAirInSizing to the maximum setpoint value to do sizing based on the maximum fan and cpu power of the ite // object SetPointManager::GetSetPointManagerInputs(state); for (auto *spm : state.dataSetPointManager->spms) { @@ -7028,7 +7028,7 @@ namespace InternalHeatGains { state.dataHeatBal->space(spaceNum).Name); } - // Not applicable for space until space has it's own air temeratures + // Not applicable for space until space has it's own air temperatures // Setup Output Variable(state, // "Space ITE Adjusted Return Air Temperature", // Constant::Units::W, @@ -9459,7 +9459,7 @@ namespace InternalHeatGains { // DATE WRITTEN Feb. 2012 // PURPOSE OF THIS SUBROUTINE: - // worker routine for summing all the internal gain types based on the existing subrotine SumAllInternalCO2Gains + // worker routine for summing all the internal gain types based on the existing subroutine SumAllInternalCO2Gains // Return value Real64 SumGCGainRate(0.0); diff --git a/src/EnergyPlus/LowTempRadiantSystem.cc b/src/EnergyPlus/LowTempRadiantSystem.cc index ed815c3fcc1..a66ce510212 100644 --- a/src/EnergyPlus/LowTempRadiantSystem.cc +++ b/src/EnergyPlus/LowTempRadiantSystem.cc @@ -128,7 +128,7 @@ namespace LowTempRadiantSystem { // (b) constant flow, variable controlled temperature heating/cooling radiant // system; (c) electric resistance heating radiant system. Systems (a) and // (b) are hydronic systems--one which varies hydronic flow as the key control - // paramter (a) and one which varies the inlet hydronic temperature while + // parameter (a) and one which varies the inlet hydronic temperature while // keeping the flow rate through the radiant system constant (b). In system // (b), the injection rate from the main water loop is varied to obtain the // proper inlet temperature. @@ -288,7 +288,7 @@ namespace LowTempRadiantSystem { int constexpr iHeatCapacityPerFloorAreaNumericNum( 2); // get input index to Low Temperature Radiant system electric heating capacity per floor area sizing int constexpr iHeatFracOfAutosizedCapacityNumericNum( - 3); // get input index to Low Temperature Radiant system electric heating capacity sizing as fraction of autozized heating capacity + 3); // get input index to Low Temperature Radiant system electric heating capacity sizing as fraction of autosized heating capacity // SUBROUTINE LOCAL VARIABLE DECLARATIONS: std::string CurrentModuleObject; // for ease in getting objects @@ -2535,14 +2535,14 @@ namespace LowTempRadiantSystem { { // Since this is only called when the operating mode is something other than "not operating", // the status from the previous system time step is what it did in the last or previous time step. - // So, we can update the last status of the system using this information before reseting things + // So, we can update the last status of the system using this information before resetting things // to "not operating". this->lastOperatingMode = this->OperatingMode; if (state.dataGlobal->BeginDayFlag) { // The begin day flag is set which mean this is the first time step of the day. // This also means that the previous time step was the last time step of yesterday. - // So, the day should be the previous day, the hour should bethe last hour of the + // So, the day should be the previous day, the hour should be the last hour of the // day, and the time step should be the last time step. this->lastDayOfSim = state.dataGlobal->DayOfSim - 1; this->lastHourOfDay = int(Constant::HoursInDay); @@ -2659,12 +2659,12 @@ namespace LowTempRadiantSystem { Real64 rho; Real64 Cp; bool IsAutoSize(false); // Indicator to autosize - Real64 WaterVolFlowMaxHeatDes(0.0); // Design hot water flow for reproting + Real64 WaterVolFlowMaxHeatDes(0.0); // Design hot water flow for reporting Real64 WaterVolFlowMaxHeatUser(0.0); // User hard-sized hot water flow for - Real64 WaterVolFlowMaxCoolDes(0.0); // Design chilled water flow for reproting - Real64 WaterVolFlowMaxCoolUser(0.0); // User hard-sized chilled water flow for reproting - Real64 TubeLengthDes(0.0); // Design tube length for reproting - Real64 TubeLengthUser(0.0); // User hard-sized tube length for reproting + Real64 WaterVolFlowMaxCoolDes(0.0); // Design chilled water flow for reporting + Real64 WaterVolFlowMaxCoolUser(0.0); // User hard-sized chilled water flow for reporting + Real64 TubeLengthDes(0.0); // Design tube length for reporting + Real64 TubeLengthUser(0.0); // User hard-sized tube length for reporting std::string CompName; // component name std::string CompType; // component type std::string SizingString; // input field sizing description (e.g., Nominal Capacity) @@ -2674,8 +2674,8 @@ namespace LowTempRadiantSystem { int CapSizingMethod; // capacity sizing methods (HeatingDesignCapacity, CapacityPerFloorArea, FractionOfAutosizedCoolingCapacity, and // FractionOfAutosizedHeatingCapacity ) Real64 DesCoilLoad; // design autosized or user specified capacity - Real64 WaterVolFlowMaxDes; // Design water volume flow rate for reproting - Real64 WaterVolFlowMaxUser; // User hard-sized water volume flow rate for reproting + Real64 WaterVolFlowMaxDes; // Design water volume flow rate for reporting + Real64 WaterVolFlowMaxUser; // User hard-sized water volume flow rate for reporting DesCoilLoad = 0.0; state.dataSize->DataScalableCapSizingON = false; diff --git a/src/EnergyPlus/MicroCHPElectricGenerator.cc b/src/EnergyPlus/MicroCHPElectricGenerator.cc index 8694908e136..60252acc2d7 100644 --- a/src/EnergyPlus/MicroCHPElectricGenerator.cc +++ b/src/EnergyPlus/MicroCHPElectricGenerator.cc @@ -266,7 +266,7 @@ void GetMicroCHPGeneratorInput(EnergyPlusData &state) } if (!(allocated(state.dataCHPElectGen->MicroCHP))) { - state.dataCHPElectGen->MicroCHP.allocate(state.dataCHPElectGen->NumMicroCHPs); // inits handeled in derived type definitions + state.dataCHPElectGen->MicroCHP.allocate(state.dataCHPElectGen->NumMicroCHPs); // inits handled in derived type definitions } // load in Micro CHPs @@ -884,7 +884,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s Real64 ThermEff = 0.0; switch (CurrentOpMode) { - case DataGenerators::OperatingMode::Off: { // same as standby in model spec but no Pnet standby electicity losses. + case DataGenerators::OperatingMode::Off: { // same as standby in model spec but no Pnet standby electricity losses. Qgenss = 0.0; TcwIn = state.dataLoopNodes->Node(this->PlantInletNodeID).Temp; // C @@ -959,7 +959,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s NdotFuel = MdotFuel / state.dataGenerator->FuelSupply(this->FuelSupplyID).KmolPerSecToKgPerSec; Qgross = NdotFuel * (state.dataGenerator->FuelSupply(this->FuelSupplyID).LHV * 1000.0 * 1000.0); - for (int i = 1; i <= 20; ++i) { // iterating here could add use of seach method + for (int i = 1; i <= 20; ++i) { // iterating here could add use of search method Pnetss = Qgross * ElecEff; if (this->A42Model.InternalFlowControl) { MdotCW = GeneratorDynamicsManager::FuncDetermineCWMdotForInternalFlowControl(state, this->DynamicsControlID, Pnetss, TcwIn); @@ -1066,7 +1066,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s NdotFuel = MdotFuel / state.dataGenerator->FuelSupply(this->FuelSupplyID).KmolPerSecToKgPerSec; Qgross = NdotFuel * (state.dataGenerator->FuelSupply(this->FuelSupplyID).LHV * 1000.0 * 1000.0); - for (int i = 1; i <= 20; ++i) { // iterating here, could add use of seach method error signal + for (int i = 1; i <= 20; ++i) { // iterating here, could add use of search method error signal Pnetss = Qgross * ElecEff; if (this->A42Model.InternalFlowControl) { MdotCW = GeneratorDynamicsManager::FuncDetermineCWMdotForInternalFlowControl(state, this->DynamicsControlID, Pnetss, TcwIn); @@ -1219,7 +1219,7 @@ Real64 FuncDetermineEngineTemp(Real64 const TcwOut, // hot water leaving temp // RE-ENGINEERED na // PURPOSE OF THIS FUNCTION: - // Calculate engine temperaure, + // Calculate engine temperature, // METHODOLOGY EMPLOYED: // model is dynamic in that previous condition affects current timestep @@ -1248,7 +1248,7 @@ Real64 FuncDetermineCoolantWaterExitTemp(Real64 const TcwIn, // hot water i // RE-ENGINEERED na // PURPOSE OF THIS FUNCTION: - // Calculate coolan water leaving temperaure, + // Calculate coolant water leaving temperature, // METHODOLOGY EMPLOYED: // model is dynamic in that previous condition affects current timestep diff --git a/src/EnergyPlus/MicroturbineElectricGenerator.cc b/src/EnergyPlus/MicroturbineElectricGenerator.cc index 22791b28da1..1882a9b6a94 100644 --- a/src/EnergyPlus/MicroturbineElectricGenerator.cc +++ b/src/EnergyPlus/MicroturbineElectricGenerator.cc @@ -418,7 +418,7 @@ void GetMTGeneratorInput(EnergyPlusData &state) Real64 RefFuelUseMdot = (state.dataMircoturbElectGen->MTGenerator(GeneratorNum).RefElecPowerOutput / state.dataMircoturbElectGen->MTGenerator(GeneratorNum).RefElecEfficiencyLHV) / (state.dataMircoturbElectGen->MTGenerator(GeneratorNum).FuelLowerHeatingValue * 1000.0); - // Output of Ancillary Power Modifer Curve (function of temps and fuel flow) + // Output of Ancillary Power Modifier Curve (function of temps and fuel flow) Real64 AncillaryPowerOutput = Curve::CurveValue(state, state.dataMircoturbElectGen->MTGenerator(GeneratorNum).AncillaryPowerFuelCurveNum, RefFuelUseMdot); if (std::abs(AncillaryPowerOutput - 1.0) > 0.1) { diff --git a/src/EnergyPlus/OutputReportTabular.cc b/src/EnergyPlus/OutputReportTabular.cc index bbf5530f5bc..948aaca07e0 100644 --- a/src/EnergyPlus/OutputReportTabular.cc +++ b/src/EnergyPlus/OutputReportTabular.cc @@ -553,7 +553,7 @@ void InitializeTabularMonthly(EnergyPlusData &state) // NOTE: // The bulk of this routine used to be part of the the // GetInputTabularMonthly routine but when predefined - // monthly reports were added this routine was seperated + // monthly reports were added this routine was separated // from input. // REFERENCES: @@ -1779,7 +1779,7 @@ void GetInputOutputTableSummaryReports(EnergyPlusData &state) ort->endUseNames(static_cast(Constant::EndUse::Cogeneration) + 1) = "Cogeneration"; auto &op = state.dataOutputProcessor; - // End use subs must be dynamically allocated to accomodate the end use with the most subcategories + // End use subs must be dynamically allocated to accommodate the end use with the most subcategories ort->meterNumEndUseSubBEPS.allocate(op->MaxNumSubcategories, static_cast(Constant::EndUse::Num), numResourceTypes); ort->meterNumEndUseSpTypeBEPS.allocate(op->maxNumEndUseSpaceTypes, static_cast(Constant::EndUse::Num), numResourceTypes); for (int endUse = 1; endUse <= static_cast(Constant::EndUse::Num); ++endUse) { @@ -3433,7 +3433,7 @@ void GatherBinResultsForTimestep(EnergyPlusData &state, OutputProcessor::TimeSte // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // Gathers the data each timesetp and adds the length of the + // Gathers the data each timestep and adds the length of the // timestep to the appropriate bin. // Using/Aliasing @@ -3498,7 +3498,7 @@ void GatherBinResultsForTimestep(EnergyPlusData &state, OutputProcessor::TimeSte if (ort->OutputTableBinned(iInObj).avgSum == OutputProcessor::StoreType::Sum) { // if it is a summed variable curValue /= (elapsedTime * Constant::SecInHour); } - // round the value to the number of signficant digits used in the final output report + // round the value to the number of significant digits used in the final output report if (curIntervalSize < 1) { curValue = round(curValue * 10000.0) / 10000.0; // four significant digits } else if (curIntervalSize >= 10) { @@ -4536,7 +4536,7 @@ void GatherHeatGainReport(EnergyPlusData &state, OutputProcessor::TimeStepType t // The following two columns are derived based on the values of the other columns and need to be computed on every HVAC timestep. // Opaque Surface Conduction and Other Heat Addition // Opaque Surface Conduction and Other Heat Removal - // For variables that are updated on a zone timestep basis, the values are used on the HVAC timestep but are ratioed by the + // For variables that are updated on a zone timestep basis, the values are used on the HVAC timestep but are ratio-ed by the // timestep lengths. // The peak reports follow a similar example. @@ -4721,7 +4721,7 @@ void GatherHeatGainReport(EnergyPlusData &state, OutputProcessor::TimeStepType t // Opaque Surface Conduction and Other Heat Addition // Opaque Surface Conduction and Other Heat Removal for (state.dataOutRptTab->iZoneGHGR = 1; state.dataOutRptTab->iZoneGHGR <= state.dataGlobal->NumOfZones; ++state.dataOutRptTab->iZoneGHGR) { - // ZonePreDefRep variables above already inlude zone list and group multipliers + // ZonePreDefRep variables above already include zone list and group multipliers state.dataOutRptTab->totalGHGR = ZonePreDefRep(state.dataOutRptTab->iZoneGHGR).SHGSAnPeoplAdd + ZonePreDefRep(state.dataOutRptTab->iZoneGHGR).SHGSAnLiteAdd + ZonePreDefRep(state.dataOutRptTab->iZoneGHGR).SHGSAnZoneEqHt + ZonePreDefRep(state.dataOutRptTab->iZoneGHGR).SHGSAnZoneEqCl + @@ -7720,7 +7720,7 @@ void WriteBEPSTable(EnergyPlusData &state) collapsedTotal(10) = ort->gatherTotalsBEPS(14); // other fuel 2 collapsedTotal(11) = ort->gatherTotalsBEPS(3); // district cooling <- purchased cooling collapsedTotal(12) = ort->gatherTotalsBEPS(4); // district heating water <- purchased heating - collapsedTotal(13) = ort->gatherTotalsBEPS(5); // distrcit heating steam <- purchased heating + collapsedTotal(13) = ort->gatherTotalsBEPS(5); // district heating steam <- purchased heating collapsedTotal(14) = ort->gatherTotalsBEPS(7); // water if (produceTabular) { @@ -7892,7 +7892,7 @@ void WriteBEPSTable(EnergyPlusData &state) } else { ort->OverallNetEnergyFromStorage = 0.0; } - // determine which resource is the primary heating resourse + // determine which resource is the primary heating resource int resourcePrimaryHeating = 0; Real64 heatingMaximum = 0.0; for (int iResource = 1; iResource <= 13; ++iResource) { // don't do water @@ -9719,7 +9719,7 @@ void writeBEPSEndUseBySubCatOrSpaceType(EnergyPlusData &state, WriteTable(state, tableBody, rowHead, columnHead, columnWidth); } Array1D_string rowHeadTemp(rowHead); - // Before outputing to SQL, we forward fill the End use column (rowHead) + // Before outputting to SQL, we forward fill the End use column (rowHead) // for better sql queries FillRowHead(rowHeadTemp); @@ -10192,7 +10192,7 @@ void WriteDemandEndUseSummary(EnergyPlusData &state) // show the headers of the report WriteReportHeaders(state, "Demand End Use Components Summary", "Entire Facility", OutputProcessor::StoreType::Average); - Real64 ipElectricityConversion = 1.0; // declare here so that last one used is correct for LEEED section + Real64 ipElectricityConversion = 1.0; // declare here so that last one used is correct for LEED section for (int iUnitSystem = 0; iUnitSystem <= 1; iUnitSystem++) { UnitsStyle unitsStyle_cur = ort->unitsStyle; bool produceTabular = true; @@ -10554,7 +10554,7 @@ void WriteDemandEndUseSummary(EnergyPlusData &state) } Array1D_string rowHeadTemp(rowHead); - // Before outputing to SQL, we forward fill the End use column (rowHead) (cf #7481) + // Before outputting to SQL, we forward fill the End use column (rowHead) (cf #7481) // for better sql queries FillRowHead(rowHeadTemp); @@ -10966,7 +10966,7 @@ void WriteVeriSumTable(EnergyPlusData &state) auto const &ort = state.dataOutRptTab; - // all arrays are in the format: (row, columnm) + // all arrays are in the format: (row, column) if (!ort->displayTabularVeriSum) { return; } @@ -14394,7 +14394,7 @@ int unitsFromHeading(EnergyPlusData &state, std::string &heading) return (unitConv); } -// Jan 2021: Overloaded this function to accomondate dual units output needs +// Jan 2021: Overloaded this function to accommodate dual units output needs // changes the heading that contains and SI to IP as well as providing the unit conversion index // Glazer Nov 2016 int unitsFromHeading(EnergyPlusData &state, std::string &heading, UnitsStyle unitsStyle_para) @@ -14414,7 +14414,7 @@ int unitsFromHeading(EnergyPlusData &state, std::string &heading, UnitsStyle uni return (unitConv); } -// function that returns a vector of strings when given a string with comma delimitters +// function that returns a vector of strings when given a string with comma delimiters // Glazer Nov 2016 std::vector splitCommaString(std::string const &inputString) { @@ -14968,7 +14968,7 @@ void WriteLoadComponentSummaryTables(EnergyPlusData &state) Array1D FacilityZonesHeatCompLoadTables; // zone results used for facility report - never directly output Array1D FacilityZonesCoolCompLoadTables; - // Jan 2021: The following variable is redudant in the original code, deleting the line + // Jan 2021: The following variable is redundant in the original code, deleting the line // CompLoadTablesType curCompLoadTable; // active component load table for (int iUnitSystem = 0; iUnitSystem <= 1; iUnitSystem++) { @@ -14977,7 +14977,7 @@ void WriteLoadComponentSummaryTables(EnergyPlusData &state) bool produceSQLite = false; if (produceDualUnitsFlags(iUnitSystem, ort->unitsStyle, ort->unitsStyle_SQLite, unitsStyle_cur, produceTabular, produceSQLite)) break; - // adjusted initilization location to after variable declaration for loops 2021-01-11 + // adjusted initialization location to after variable declaration for loops 2021-01-11 peopleDelaySeqHeat.dimension(state.dataGlobal->NumOfTimeStepInHour * 24, 0.0); peopleDelaySeqHeat = 0.0; peopleDelaySeqCool.allocate(state.dataGlobal->NumOfTimeStepInHour * 24); @@ -15674,7 +15674,7 @@ void GetDelaySequences(EnergyPlusData &state, (peopleConvFromSurf + equipConvFromSurf + hvacLossConvFromSurf + powerGenConvFromSurf + lightLWConvFromSurf + lightSWConvFromSurf + feneSolarConvFromSurf); // remove net radiant for the surface - // also remove the net radiant component on the instanteous conduction for fenestration + // also remove the net radiant component on the instantaneous conduction for fenestration if (state.dataSurface->Surface(jSurf).Class == DataSurfaces::SurfaceClass::Window) { adjFeneSurfNetRadSeq += ort->netSurfRadSeq(desDaySelected, kTimeStep, jSurf); } @@ -15687,7 +15687,7 @@ void GetDelaySequences(EnergyPlusData &state, // combine short wave (visible) and long wave (thermal) impacts lightDelaySeq(kTimeStep) = lightLWConvIntoZone + lightSWConvIntoZone; feneSolarDelaySeq(kTimeStep) = feneSolarConvIntoZone; - // also remove the net radiant component on the instanteous conduction for fenestration + // also remove the net radiant component on the instantaneous conduction for fenestration if (!state.dataOutRptTab->adjFenDone(desDaySelected, kTimeStep, zoneIndex)) { feneCondInstantSeq(desDaySelected, kTimeStep, zoneIndex) -= adjFeneSurfNetRadSeq; state.dataOutRptTab->adjFenDone(desDaySelected, kTimeStep, zoneIndex) = true; @@ -15997,7 +15997,7 @@ void CollectPeakZoneConditions( // Zone Dry Bulb Temperature compLoad.zoneDryBulb = thisCalcFinalZoneSizing.CoolZoneTempSeq(timeOfMax); - // Zone Relative Humdity + // Zone Relative Humidity // use standard air pressure because air pressure is not tracked with sizing data compLoad.zoneRelHum = Psychrometrics::PsyRhFnTdbWPb(state, thisCalcFinalZoneSizing.CoolZoneTempSeq(timeOfMax), @@ -16053,7 +16053,7 @@ void CollectPeakZoneConditions( // Zone Dry Bulb Temperature compLoad.zoneDryBulb = thisCalcFinalZoneSizing.HeatZoneTempSeq(timeOfMax); - // Zone Relative Humdity + // Zone Relative Humidity // use standard air pressure because air pressure is not tracked with sizing data compLoad.zoneRelHum = Psychrometrics::PsyRhFnTdbWPb(state, thisCalcFinalZoneSizing.HeatZoneTempSeq(timeOfMax), @@ -16252,7 +16252,7 @@ void AddAreaColumnForZone(int const zoneNum, Array1D con compLoad.cellUsed(LoadCompCol::Area, LoadCompRow::OpqDoor) = true; } -// Used for the AirLoop and Facility level load component tables to sum the results from invidual zones +// Used for the AirLoop and Facility level load component tables to sum the results from individual zones void CombineLoadCompResults(CompLoadTablesType &compLoadTotal, CompLoadTablesType const &compLoadPartial, Real64 const multiplier) { // sum the main results @@ -16408,7 +16408,7 @@ void LoadSummaryUnitConversion(EnergyPlusData &state, CompLoadTablesType &compLo compLoadTotal.cndPumpPerFlow *= powerPerFlowLiquidConversion; } -// Jan 2021: Overloaded the function with addtional parameters for dual units; +// Jan 2021: Overloaded the function with additional parameters for dual units; // used overloading since the original function was checked in an existing test unit. // apply unit conversions to the load components summary tables void LoadSummaryUnitConversion(EnergyPlusData &state, CompLoadTablesType &compLoadTotal, UnitsStyle unitsStyle_para) @@ -16684,7 +16684,7 @@ void OutputCompLoadSummary(EnergyPlusData &state, tableBody(1, 3) = RealToStr(curCompLoad.outsideWetBulb, 2); // Outside Wet Bulb Temperature tableBody(1, 4) = RealToStr(curCompLoad.outsideHumRatio, 5); // Outside Humidity Ratio at Peak tableBody(1, 5) = RealToStr(curCompLoad.zoneDryBulb, 2); // Zone Dry Bulb Temperature - tableBody(1, 6) = RealToStr(100 * curCompLoad.zoneRelHum, 2); // Zone Relative Humdity + tableBody(1, 6) = RealToStr(100 * curCompLoad.zoneRelHum, 2); // Zone Relative Humidity tableBody(1, 7) = RealToStr(curCompLoad.zoneHumRatio, 5); // Zone Humidity Ratio at Peak } tableBody(1, 8) = RealToStr(curCompLoad.supAirTemp, 2); // supply air temperature @@ -16735,7 +16735,7 @@ void OutputCompLoadSummary(EnergyPlusData &state, rowHead(4) = "Floor Area per Total Capacity [m2/W]"; rowHead(5) = "Total Capacity per Floor Area [W/m2]"; // rowHead( 6 ) = "Chiller Pump Power per Flow [W-s/m3]"; // facility only - // rowHead( 7 ) = "Condenser Pump Power per Flor [W-s/m3]"; // facility only + // rowHead( 7 ) = "Condenser Pump Power per Flow [W-s/m3]"; // facility only rowHead(6) = "Number of People"; } else { rowHead(1) = "Outside Air Fraction [fraction]"; @@ -17025,10 +17025,10 @@ void WriteTable(EnergyPlusData &state, int rowsRowLabels = isize(rowLabels); int colsColumnLabels = isize(columnLabels); int const colsWidthColumn = isize(widthColumn); - // check size of arrays for consistancy and if inconsistent use smaller value + // check size of arrays for consistency and if inconsistent use smaller value // and display warning if (rowsBody != rowsRowLabels) { - ShowWarningError(state, "REPORT:TABLE Inconsistant number of rows."); + ShowWarningError(state, "REPORT:TABLE Inconsistent number of rows."); rowsBody = min(rowsBody, rowsRowLabels); rowsRowLabels = rowsBody; } @@ -17043,7 +17043,7 @@ void WriteTable(EnergyPlusData &state, rowUnitStrings.allocate(rowsBody); columnUnitStrings.allocate(colsBody); bodyEsc.allocate(colsBody, rowsBody); - // create new array to hold multiple line column lables + // create new array to hold multiple line column labels colLabelMulti.allocate(colsColumnLabels, 50); colLabelMulti = blank; // set array to blank int maxNumColLabelRows = 0; @@ -18973,7 +18973,7 @@ Real64 ConvertIPdelta(EnergyPlusData &state, int const unitConvIndex, Real64 con // PURPOSE OF THIS SUBROUTINE: // Apply the selected unit conversion to the input value // expressed in SI units to result in IP units. This routine - // only uses the mulitplier and NOT the offset and is appropriate + // only uses the multiplier and NOT the offset and is appropriate // when the number being converted is a difference or delta // between values (such as a temperature difference). @@ -19025,7 +19025,7 @@ void GetUnitConversion(EnergyPlusData &state, int const unitConvIndex, Real64 &m // PURPOSE OF THIS SUBROUTINE: // Return of the multiplier and adder for the given // SI to IP unit conversion. - // SI = (IP * multipier) + offset + // SI = (IP * multiplier) + offset // This function could be replaced by referencing the // array directly but does include some checking of the // bounds of the array. @@ -19078,7 +19078,7 @@ Real64 getSpecificUnitMultiplier(EnergyPlusData &state, std::string const &SIuni // SI to IP unit conversion. No offset is provided so // it cannot be used to convert units such as temperatures // that include an offset. - // SI = (IP * multipier) + offset + // SI = (IP * multiplier) + offset // Unlike LookupSItoIP, this function does not expect more // the units in the two input parameters. No hints or // defaults are used since both the SI and IP units are @@ -19140,7 +19140,7 @@ Real64 getSpecificUnitDivider(EnergyPlusData &state, std::string const &SIunit, // SI to IP unit conversion. No offset is provided so // it cannot be used to convert units such as temperatures // that include an offset. - // SI = (IP * multipier) + offset + // SI = (IP * multiplier) + offset // Unlike LookupSItoIP, this function does not expect more // the units in the two input parameters. No hints or // defaults are used since both the SI and IP units are diff --git a/src/EnergyPlus/Photovoltaics.cc b/src/EnergyPlus/Photovoltaics.cc index c0915d7d42a..9e7f958d900 100644 --- a/src/EnergyPlus/Photovoltaics.cc +++ b/src/EnergyPlus/Photovoltaics.cc @@ -173,7 +173,7 @@ namespace Photovoltaics { CalcSimplePV(state, PVnum); } break; case PVModel::TRNSYS: { - // 'PhotovoltaicPeformance:EquivalentOne-Diode' (aka. 5-parameter TRNSYS type 180 model) + // 'PhotovoltaicPerformance:EquivalentOne-Diode' (aka. 5-parameter TRNSYS type 180 model) InitTRNSYSPV(state, PVnum); CalcTRNSYSPV(state, PVnum, RunFlag); @@ -206,7 +206,7 @@ namespace Photovoltaics { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // provide a "get" method to collect results for individual electic load centers. + // provide a "get" method to collect results for individual electric load centers. // Using/Aliasing using PhotovoltaicThermalCollectors::GetPVTThermalPowerProduction; @@ -324,7 +324,7 @@ namespace Photovoltaics { ShowWarningError(state, format("Invalid {} = {}", state.dataIPShortCut->cAlphaFieldNames(2), state.dataIPShortCut->cAlphaArgs(2))); ShowContinueError(state, format("Entered in {} = {}", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); - ShowContinueError(state, "Surface is not exposed to solar, check surface bounday condition"); + ShowContinueError(state, "Surface is not exposed to solar, check surface boundary condition"); } state.dataPhotovoltaic->PVarray(PVnum).Zone = GetPVZone(state, state.dataPhotovoltaic->PVarray(PVnum).SurfacePtr); @@ -836,7 +836,7 @@ namespace Photovoltaics { state.dataHeatBal->SurfQRadSWOutIncident( ThisSurf); // active solar cellsurface net area | solar conversion efficiency | solar incident - // store sink term in appropriate place for surface heat transfer itegration + // store sink term in appropriate place for surface heat transfer integration state.dataPhotovoltaic->PVarray(thisPV).SurfaceSink = state.dataPhotovoltaic->PVarray(thisPV).Report.DCPower; // array energy, power * timestep @@ -919,7 +919,7 @@ namespace Photovoltaics { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // Calculate various PV system peformance indicies at the current timestep + // Calculate various PV system performance indices at the current timestep // METHODOLOGY EMPLOYED: // adapted code from a set of F77 routines by G. Barker that implement the model @@ -1071,7 +1071,7 @@ namespace Photovoltaics { thisPVarray.SNLPVModule.BVoc0, thisPVarray.SNLPVModule.mBVoc); - // Calculate Vmp: voltagea at maximum powerpoint + // Calculate Vmp: voltage at maximum powerpoint thisPVarray.SNLPVCalc.Vmp = SandiaVmp(thisPVarray.SNLPVCalc.Tcell, Ee, thisPVarray.SNLPVModule.Vmp0, @@ -1357,7 +1357,7 @@ namespace Photovoltaics { state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.Vmp + state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.RefVoc) / state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.Imp; - // temperature depencence + // temperature dependence IL = state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVcalc.Insolation / state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.RefInsolation * (ILRef + state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.TempCoefIsc * @@ -1369,7 +1369,7 @@ namespace Photovoltaics { state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.CellsInSeries / AARef * (1.0 - state.dataPhotovoltaic->PVarray(PVnum).TRNSYSPVModule.RefTemperature / CellTemp)); - // compute short curcuit current and open circuit voltage + // compute short circuit current and open circuit voltage // NEWTON --> ISC (STARTVALUE: ISCG1 - BASED ON IL=ISC) ISCG1 = IL; @@ -1753,7 +1753,7 @@ namespace Photovoltaics { // METHODOLOGY EMPLOYED: // apply sandia temperature model, This is module temp or back of - // of the panel. A seperate correction handles delta T for actual cell + // of the panel. A separate correction handles delta T for actual cell // REFERENCES: // from G. Barker's TRNSYS implementation @@ -1930,7 +1930,7 @@ namespace Photovoltaics { // AUTHOR G. Barker // DATE WRITTEN // MODIFIED na - // RE-ENGINEERED B. Griffit F77-> f90 + // RE-ENGINEERED B. Griffith F77-> f90 // PURPOSE OF THIS FUNCTION: // Returns the result of Sandia Air Mass function @@ -2229,7 +2229,7 @@ namespace Photovoltaics { // SUBROUTINE INFORMATION: // AUTHOR B. Griffith - // DATE WRITTEN Janauray 2004 + // DATE WRITTEN January 2004 // MODIFIED na // RE-ENGINEERED na diff --git a/src/EnergyPlus/Plant/PlantManager.cc b/src/EnergyPlus/Plant/PlantManager.cc index fe4308a50fc..1657f59291b 100644 --- a/src/EnergyPlus/Plant/PlantManager.cc +++ b/src/EnergyPlus/Plant/PlantManager.cc @@ -152,7 +152,7 @@ void ManagePlantLoops(EnergyPlusData &state, bool &SimZoneEquipment, // True when zone equipment components need to be (re)simulated [[maybe_unused]] bool &SimNonZoneEquipment, // True when non-zone equipment components need to be (re)simulated bool &SimPlantLoops, // True when some part of Plant needs to be (re)simulated - bool &SimElecCircuits // True when electic circuits need to be (re)simulated + bool &SimElecCircuits // True when electric circuits need to be (re)simulated ) { @@ -2238,7 +2238,7 @@ void InitializeLoops(EnergyPlusData &state, bool const FirstHVACIteration) // tr // demand. Long term, I recommend that we: // 1. specify the setpointmanager:plant object name (not the node name) in the plantloop/condloop objects // 2. write a new setpoint manager (setpointmanager:plant) that is more suitable for plant use and - // accomodates AIR and GROUND setpoints...with offsets. + // accommodates AIR and GROUND setpoints...with offsets. //***************************************************************** // ONE TIME LOOP NODE SETPOINT CHECK @@ -2369,7 +2369,7 @@ void InitializeLoops(EnergyPlusData &state, bool const FirstHVACIteration) // tr // END First Pass SIZING INIT //***************************************************************** //***************************************************************** - // BEGIN Resizing Pass for HVAC Sizing Simultion Adjustments + // BEGIN Resizing Pass for HVAC Sizing Simulation Adjustments //***************************************************************** if (state.dataGlobal->RedoSizesHVACSimulation && !state.dataPlnt->PlantReSizingCompleted) { @@ -2862,7 +2862,7 @@ void CheckPlantOnAbort(EnergyPlusData &state) // SUBROUTINE INFORMATION: // AUTHOR Brent Griffith - // DATE WRITTEN Septemeber 2006 + // DATE WRITTEN September 2006 // MODIFIED na // RE-ENGINEERED na @@ -3335,7 +3335,7 @@ void SizePlantLoop(EnergyPlusData &state, if (state.dataPlnt->PlantLoop(LoopNum).FluidType == DataLoopNode::NodeFluidType::Water) { FluidDensity = FluidProperties::GetDensityGlycol( state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, state.dataPlnt->PlantLoop(LoopNum).FluidIndex, RoutineName); - if (PlantSizNum > 0 && allocated(state.dataSize->PlantSizData)) { // method only works if sizing delta T is avaiable + if (PlantSizNum > 0 && allocated(state.dataSize->PlantSizData)) { // method only works if sizing delta T is available Real64 cp = FluidProperties::GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(LoopNum).FluidName, Constant::InitConvTemp, @@ -3506,7 +3506,7 @@ void SetupInitialPlantCallingOrder(EnergyPlusData &state) // METHODOLOGY EMPLOYED: // simple rule-based allocation of which order to call the half loops - // initially just mimicing historical practice until a better set of rules is + // initially just mimicking historical practice until a better set of rules is // developed // 1. first call all plant demand sides // 2. second call all plant supply sides @@ -3558,7 +3558,7 @@ void RevisePlantCallingOrder(EnergyPlusData &state) // SUBROUTINE INFORMATION: // AUTHOR Brent Griffith - // DATE WRITTEN april 2011 + // DATE WRITTEN April 2011 // MODIFIED na // RE-ENGINEERED na @@ -4509,7 +4509,7 @@ void CheckIfAnyPlant(EnergyPlusData &state) // determine if any plant loops will be ever be set up // METHODOLOGY EMPLOYED: - // use input processor ot find number of plant loops + // use input processor to find number of plant loops // Using/Aliasing // SUBROUTINE LOCAL VARIABLE DECLARATIONS: @@ -4540,7 +4540,7 @@ void CheckOngoingPlantWarnings(EnergyPlusData &state) ShowWarningError( state, "Plant Loop: " + state.dataPlnt->PlantLoop(LoopNum).Name + " Demand Side is storing excess heat the majority of the time."); ShowContinueError(state, - format("Excesss Storage Time={:.2R}[hr], Total Loop Active Time={:.2R}[hr]", + format("Excess Storage Time={:.2R}[hr], Total Loop Active Time={:.2R}[hr]", state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideLocation::Supply).LoopSideInlet_CapExcessStorageTime, state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideLocation::Demand).LoopSideInlet_TotalTime)); } @@ -4549,7 +4549,7 @@ void CheckOngoingPlantWarnings(EnergyPlusData &state) ShowWarningError( state, "Plant Loop: " + state.dataPlnt->PlantLoop(LoopNum).Name + " Supply Side is storing excess heat the majority of the time."); ShowContinueError(state, - format("Excesss Storage Time={:.2R}[hr], Total Loop Active Time={:.2R}[hr]", + format("Excess Storage Time={:.2R}[hr], Total Loop Active Time={:.2R}[hr]", state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideLocation::Supply).LoopSideInlet_CapExcessStorageTime, state.dataPlnt->PlantLoop(LoopNum).LoopSide(LoopSideLocation::Demand).LoopSideInlet_TotalTime)); } diff --git a/src/EnergyPlus/PlantChillers.cc b/src/EnergyPlus/PlantChillers.cc index b5ebfc224c5..2db0f0df25b 100644 --- a/src/EnergyPlus/PlantChillers.cc +++ b/src/EnergyPlus/PlantChillers.cc @@ -3498,7 +3498,7 @@ namespace PlantChillers { // calculate end time of current time step Real64 CurrentEndTime = state.dataGlobal->CurrentTime + state.dataHVACGlobal->SysTimeElapsed; - // Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. + // Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. // Wait for next time step to print warnings. If simulation iterates, print out // the warning for the last iteration only. Must wait for next time step to accomplish this. // If a warning occurs and the simulation down shifts, the warning is not valid. @@ -3679,7 +3679,7 @@ namespace PlantChillers { } this->Power = FracFullLoadPower * FullLoadPowerRat * AvailChillerCap / COPLocal * FRAC; - // Either set the flow to the Constant value or caluclate the flow for the variable volume + // Either set the flow to the Constant value or calculate the flow for the variable volume if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { // Start by assuming max (design) flow this->EvapMassFlowRate = this->EvapMassFlowRateMax; @@ -5683,7 +5683,7 @@ namespace PlantChillers { } this->Power = FracFullLoadPower * FullLoadPowerRat * AvailChillerCap / COP * FRAC; - // Either set the flow to the Constant value or caluclate the flow for the variable volume + // Either set the flow to the Constant value or calculate the flow for the variable volume if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { // Start by assuming max (design) flow this->EvapMassFlowRate = this->EvapMassFlowRateMax; @@ -7248,7 +7248,7 @@ namespace PlantChillers { // calculate end time of current time step Real64 const CurrentEndTime = state.dataGlobal->CurrentTime + state.dataHVACGlobal->SysTimeElapsed; - // Print warning messages only when valid and only for the first ocurrance. Let summary provide statistics. + // Print warning messages only when valid and only for the first occurrence. Let summary provide statistics. // Wait for next time step to print warnings. If simulation iterates, print out // the warning for the last iteration only. Must wait for next time step to accomplish this. // If a warning occurs and the simulation down shifts, the warning is not valid. @@ -7330,7 +7330,7 @@ namespace PlantChillers { this->PossibleSubcooling = false; this->QEvaporator = std::abs(MyLoad); - // Either set the flow to the Constant value or caluclate the flow for the variable volume + // Either set the flow to the Constant value or calculate the flow for the variable volume if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { // Start by assuming max (design) flow @@ -7419,7 +7419,7 @@ namespace PlantChillers { return; } - // Recalculate the Delts Temp + // Recalculate the Delta Temp if (this->PossibleSubcooling) { this->QEvaporator = std::abs(MyLoad); EvapDeltaTemp = this->QEvaporator / this->EvapMassFlowRate / Cp; diff --git a/src/EnergyPlus/PlantPressureSystem.cc b/src/EnergyPlus/PlantPressureSystem.cc index 0512ee9a99a..7c8ab207f68 100644 --- a/src/EnergyPlus/PlantPressureSystem.cc +++ b/src/EnergyPlus/PlantPressureSystem.cc @@ -820,7 +820,7 @@ Real64 ResolveLoopFlowVsPressure(EnergyPlusData &state, // find a more realistic operating point for the plant. // METHODOLOGY EMPLOYED: - // Pressure drop of complete loop is found for a perticular flow rate. + // Pressure drop of complete loop is found for a particular flow rate. // i.e. pressuredrop = K * massflow ^ 2 // System curve is then solved with pump curve already entered // and flow rate provided by the pump will be calculated. @@ -912,7 +912,7 @@ Real64 ResolveLoopFlowVsPressure(EnergyPlusData &state, // Get the pump curve value from the curve manager PsiPump = CurveValue(state, PumpCurveNum, PhiPump); - // Calcuate Pump Pressure rise + // Calculate Pump Pressure rise PumpPressureRise = PsiPump * NodeDensity * pow_2(PumpSpeed) * pow_2(PumpImpellerDia); // Convergence Criteria Based on Pressure diff --git a/src/EnergyPlus/PurchasedAirManager.cc b/src/EnergyPlus/PurchasedAirManager.cc index af26373459a..fcd4824133a 100644 --- a/src/EnergyPlus/PurchasedAirManager.cc +++ b/src/EnergyPlus/PurchasedAirManager.cc @@ -1990,7 +1990,7 @@ void CalcPurchAirLoads(EnergyPlusData &state, int RecircNodeNum; // Return air or zone exhaust node OpMode OperatingMode; // current operating mode, Off, Heat, Cool, or DeadBand Real64 SupplyMassFlowRate; // System supply air mass flow rate [kg/s] - Real64 SupplyMassFlowRateForHumid; // System supply air mass flow rate required to meet humdification load [kg/s] + Real64 SupplyMassFlowRateForHumid; // System supply air mass flow rate required to meet humidification load [kg/s] Real64 SupplyMassFlowRateForDehum; // System supply air mass flow rate required to meet dehumidification load [kg/s] Real64 SupplyMassFlowRateForCool; // System supply air mass flow rate required to meet sensible cooling load[kg/s] Real64 SupplyMassFlowRateForHeat; // System supply air mass flow rate required to meet sensible heating load[kg/s] @@ -2000,10 +2000,10 @@ void CalcPurchAirLoads(EnergyPlusData &state, Real64 OAVolFlowRate; // Outdoor air volume flow rate at standard density [m3/s] Real64 MinOASensOutput; // Minimum Outdoor air sensible output [W], <0 means OA is cooler than zone air Real64 MinOALatOutput; // Minimum Outdoor air moisture load [kg/s] - Real64 SensOutput; // Sensible output [W] (psitive means heating, negative means cooling) + Real64 SensOutput; // Sensible output [W] (positive means heating, negative means cooling) Real64 HeatSensOutput; // Heating sensible output [W] - Real64 CoolSensOutput; // Cooling sensible output [W] (positive value menas cooling) - Real64 LatOutput; // Latent output [W] (positive value means hudmification, negative means dehumidification) + Real64 CoolSensOutput; // Cooling sensible output [W] (positive value means cooling) + Real64 LatOutput; // Latent output [W] (positive value means humidification, negative means dehumidification) Real64 CoolLatOutput; // Cooling latent output [W] (positive value means dehumidification) Real64 CoolTotOutput; // Cooling total output [W] (positive value means cooling) Real64 DeltaT; // Delta temperature - reused in multiple places @@ -2013,8 +2013,8 @@ void CalcPurchAirLoads(EnergyPlusData &state, Real64 MdotZnHumidSP; // Load required to meet humidifying setpoint [kgWater/s] (>0 = a humidify load) Real64 MdotZnDehumidSP; // Load required to meet dehumidifying setpoint [kgWater/s] (<0 = a dehumidify load) bool UnitOn; - bool HeatOn; // Flag for heating and humidification availbility schedule, true if heating is on - bool CoolOn; // Flag for cooling and dehumidification availbility schedule, true if cooling is on + bool HeatOn; // Flag for heating and humidification availability schedule, true if heating is on + bool CoolOn; // Flag for cooling and dehumidification availability schedule, true if cooling is on bool EconoOn; // Flag for economizer operation, true if economizer is on Real64 SupplyHumRatOrig; // Supply inlet to zone humidity ratio before saturation check [kgWater/kgDryAir] Real64 SupplyHumRatSat; // Supply inlet to zone humidity ratio saturation at SupplyTemp [kgWater/kgDryAir] @@ -2369,7 +2369,7 @@ void CalcPurchAirLoads(EnergyPlusData &state, break; } // Limit supply humidity ratio to saturation at supply outlet temp - // If saturation exceeded, then honor capacity limit and set to dew point at supplyenthalpy + // If saturation exceeded, then honor capacity limit and set to dew point at supply enthalpy SupplyHumRatOrig = PurchAir.SupplyHumRat; SupplyHumRatSat = PsyWFnTdbRhPb(state, PurchAir.SupplyTemp, 1.0, state.dataEnvrn->OutBaroPress, RoutineName); @@ -2636,7 +2636,7 @@ void CalcPurchAirLoads(EnergyPlusData &state, } // Cooling or heating required if (SupplyMassFlowRate > 0.0) { - // EMS override point Purch air supply temp and humidty ratio ..... but only if unit is on, SupplyMassFlowRate>0.0 + // EMS override point Purch air supply temp and humidity ratio ..... but only if unit is on, SupplyMassFlowRate>0.0 if (PurchAir.EMSOverrideSupplyTempOn) { PurchAir.SupplyTemp = PurchAir.EMSValueSupplyTemp; } @@ -2674,7 +2674,7 @@ void CalcPurchAirLoads(EnergyPlusData &state, PurchAir.SupplyHumRat = PurchAir.MixedAirHumRat; } - // Double-check if saturation exceeded, then thow warning, shouldn't happen here, don't reset, just warn + // Double-check if saturation exceeded, then throw warning, shouldn't happen here, don't reset, just warn SupplyHumRatOrig = PurchAir.SupplyHumRat; SupplyHumRatSat = PsyWFnTdbRhPb(state, PurchAir.SupplyTemp, 1.0, state.dataEnvrn->OutBaroPress, RoutineName); @@ -3004,7 +3004,7 @@ void UpdatePurchasedAir(EnergyPlusData &state, int const PurchAirNum, bool const bool FirstCall; bool SupPathInletChanged; - FirstCall = true; // just used to avoid redundant calulations + FirstCall = true; // just used to avoid redundant calculations SupPathInletChanged = false; // don't care if something changes auto &PurchAir = state.dataPurchasedAirMgr->PurchAir(PurchAirNum); @@ -3137,7 +3137,7 @@ Real64 GetPurchasedAirOutAirMassFlow(EnergyPlusData &state, int const PurchAirNu // lookup function for OA inlet mass flow for ventilation rate reporting // METHODOLOGY EMPLOYED: - // most analagous functions look up an outside air node but this function + // most analogous functions look up an outside air node but this function // gets the actual mass flow of outdoor air, following the features of the model if (state.dataPurchasedAirMgr->GetPurchAirInputFlag) { @@ -3226,7 +3226,7 @@ Real64 GetPurchasedAirMixedAirTemp(EnergyPlusData &state, int const PurchAirNum) // lookup function for mixed air Temp for ventilation rate reporting // METHODOLOGY EMPLOYED: - // most analagous functions look up an outside air node but this function + // most analogous functions look up an outside air node but this function // gets the actual mass flow of outdoor air, following the features of the model if (state.dataPurchasedAirMgr->GetPurchAirInputFlag) { @@ -3315,13 +3315,13 @@ void InitializePlenumArrays(EnergyPlusData &state, int const PurchAirNum) // PurchAirPlenumArrays( 1 ).IsSimulated( 1 ) = true, ideal loads air system #1 has been simulated this iteration // PurchAirPlenumArrays( 1 ).IsSimulated( 2 ) = false, ideal loads air system #3 has not yet been simulated this iteration // - // Ideal loads air sytems keep track of which plenum they are connected to + // Ideal loads air systems keep track of which plenum they are connected to // PurchAir( 1 ).PlenumArrayIndex = 1 // PurchAir( 1 ).ReturnPlenumName = ReturnPlenum2; // PurchAir( 3 ).PlenumArrayIndex = 1 // PurchAir( 3 ).ReturnPlenumName = ReturnPlenum2; // - // The ideal loads air sytems also keep track of which item they are in the int and bool arrays + // The ideal loads air systems also keep track of which item they are in the int and bool arrays // PurchAir( 1 ).PurchAirArrayIndex = 1 // PurchAir( 3 ).PurchAirArrayIndex = 2 // @@ -3334,7 +3334,7 @@ void InitializePlenumArrays(EnergyPlusData &state, int const PurchAirNum) // PurchAirPlenumArrays( 2 ).IsSimulated( 2 ) = false, ideal loads air system #5 has not yet been simulated this iteration // PurchAirPlenumArrays( 2 ).IsSimulated( 3 ) = false, ideal loads air system #6 has not yet been simulated this iteration // - // Ideal loads air sytems keep track of which plenum they are connected to + // Ideal loads air systems keep track of which plenum they are connected to // PurchAir( 2 ).PlenumArrayIndex = 2; // PurchAir( 2 ).ReturnPlenumName = ReturnPlenum3; // PurchAir( 5 ).PlenumArrayIndex = 2; @@ -3342,7 +3342,7 @@ void InitializePlenumArrays(EnergyPlusData &state, int const PurchAirNum) // PurchAir( 6 ).PlenumArrayIndex = 2; // PurchAir( 6 ).ReturnPlenumName = ReturnPlenum3; // - // The ideal loads air sytems also keep track of which item they are in the int and bool arrays + // The ideal loads air systems also keep track of which item they are in the int and bool arrays // PurchAir( 2 ).PurchAirArrayIndex = 1; // PurchAir( 5 ).PurchAirArrayIndex = 2; // PurchAir( 6 ).PurchAirArrayIndex = 3; diff --git a/src/EnergyPlus/RefrigeratedCase.cc b/src/EnergyPlus/RefrigeratedCase.cc index ec4e4873db0..455d4f0211a 100644 --- a/src/EnergyPlus/RefrigeratedCase.cc +++ b/src/EnergyPlus/RefrigeratedCase.cc @@ -114,7 +114,7 @@ namespace EnergyPlus::RefrigeratedCase { // sensible case credit). The case (evaporator) fans are assumed to be disabled during hot-gas or // electric defrost modes. A stocking schedule (W/m) is available for added load if desired. // Walk-In coolers are simulated based on the specified sum of the conductance*area of each wall and door facing -// up to three (extendible) zones. Two types of doors are specified, stock doors and glass doors. For each category +// up to three (extensible) zones. Two types of doors are specified, stock doors and glass doors. For each category // of doors, schedules for door openings are used with ASHRAE models for infiltration // which are a function of the height of the door. That // infiltration is used to calculate the latent load on the cooler and the latent case credits for each zone. @@ -3449,7 +3449,7 @@ void GetRefrigerationInput(EnergyPlusData &state) if (state.dataRefrigCase->NumRefrigSystems > 0 && state.dataRefrigCase->NumRefrigCondensers == 0) { ShowSevereError(state, - "Refrigeration:System objects were found during input processing, however no Rrefrigeration condenser objects (which " + "Refrigeration:System objects were found during input processing, however no Refrigeration condenser objects (which " "may be either: "); ShowContinueError(state, " Refrigeration:Condenser:AirCooled, Refrigeration:Condenser:WaterCooled, " @@ -4952,7 +4952,7 @@ void GetRefrigerationInput(EnergyPlusData &state) ShowWarningError( state, format("{}{}=\"{}\", {} not found even though {} is greater than zero. Distribution piping heat gain will not be " - "calculated unless a Zone is defined to deterimine the environmental temperature surrounding the piping.", + "calculated unless a Zone is defined to determine the environmental temperature surrounding the piping.", RoutineName, CurrentModuleObject, Secondary(SecondaryNum).Name, @@ -5013,7 +5013,7 @@ void GetRefrigerationInput(EnergyPlusData &state) ShowWarningError( state, format("{}{}=\"{}\", {} not found even though {} is greater than zero. Receiver heat gain will not be calculated unless " - "a Zone is defined to deterimine the environmental temperature surrounding the Receiver.", + "a Zone is defined to determine the environmental temperature surrounding the Receiver.", RoutineName, CurrentModuleObject, Secondary(SecondaryNum).Name, @@ -6072,7 +6072,7 @@ void GetRefrigerationInput(EnergyPlusData &state) ShowSevereError( state, format("{}{}=\"{}\", System Node Number not found for {} = {} even though {} is greater than zero. Suction piping heat gain " - "cannot be calculated unless a Zone is defined to deterimine the environmental temperature surrounding the piping.", + "cannot be calculated unless a Zone is defined to determine the environmental temperature surrounding the piping.", RoutineName, CurrentModuleObject, System(RefrigSysNum).Name, @@ -6260,7 +6260,7 @@ void GetRefrigerationInput(EnergyPlusData &state) NominalTotalCompCap += Compressor(CompNum).NomCap; ++Compressor(CompNum).NumSysAttach; } // NumStages - } else { // Transcritical compressor attached to subcritical refigeration cycle + } else { // Transcritical compressor attached to subcritical refrigeration cycle ShowSevereError(state, format("{}{}. A transcritical compressor is attached to a subcritical refrigeration system.", RoutineName, @@ -6285,7 +6285,7 @@ void GetRefrigerationInput(EnergyPlusData &state) Condenser(System(RefrigSysNum).CondenserNum(1)).RatedTCondense); NominalTotalHiStageCompCap += Compressor(CompNum).NomCap; ++Compressor(CompNum).NumSysAttach; - } else { // Transcritical compressor attached to subcritical refigeration cycle + } else { // Transcritical compressor attached to subcritical refrigeration cycle ShowSevereError(state, format("{}{}. A transcritical compressor is attached to a subcritical refrigeration system.", RoutineName, @@ -7008,7 +7008,7 @@ void GetRefrigerationInput(EnergyPlusData &state) // Check subcooler effectiveness value, must be value between 0 and 1 if ((TransSystem(TransRefrigSysNum).SCEffectiveness < 0) || (TransSystem(TransRefrigSysNum).SCEffectiveness > 1)) { ShowSevereError(state, - format("{}{}=\"{}: The value for subcooler effectivness is invalid. The subcooler effectivenss must be a value " + format("{}{}=\"{}: The value for subcooler effectiveness is invalid. The subcooler effectiveness must be a value " "greater than or equal to zero and less than or equal to one.", RoutineName, CurrentModuleObject, @@ -7040,7 +7040,7 @@ void GetRefrigerationInput(EnergyPlusData &state) cNumericFieldNames(3))); ShowContinueError(state, " The medium temperature suction piping heat gain cannot be calculated unless a Zone is defined to " - "deterimine the environmental temperature surrounding the piping."); + "determine the environmental temperature surrounding the piping."); ErrorsFound = true; } else { state.dataRefrigCase->RefrigPresentInZone(TransSystem(TransRefrigSysNum).SuctionPipeActualZoneNumMT) = true; @@ -7084,7 +7084,7 @@ void GetRefrigerationInput(EnergyPlusData &state) cNumericFieldNames(4))); ShowContinueError(state, " The low temperature suction piping heat gain cannot be calculated unless a Zone is defined to " - "deterimine the environmental temperature surrounding the piping."); + "determine the environmental temperature surrounding the piping."); ErrorsFound = true; } else { state.dataRefrigCase->RefrigPresentInZone(TransSystem(TransRefrigSysNum).SuctionPipeActualZoneNumLT) = true; @@ -7848,7 +7848,7 @@ void SetupReportInput(EnergyPlusData &state) // Report walkin variables that are specified for each zone exposed to the walkin // For "IDOut" variable in SetupOutputVariable, need to create a single name that includes - // both the walk-in name and the zone name - see "Walkin_and_zone_name" concatination + // both the walk-in name and the zone name - see "Walkin_and_zone_name" concatenation // This new variable name is important if using an rvi file! for (int zoneId = 1; zoneId <= walkin.NumZones; ++zoneId) { @@ -7980,7 +7980,7 @@ void SetupReportInput(EnergyPlusData &state) coil.TotalElecConsumption, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Sum, - coil.Name); // components are metered seperately + coil.Name); // components are metered separately SetupOutputVariable(state, "Refrigeration Zone Air Chiller Fan Electricity Rate", Constant::Units::W, @@ -10390,7 +10390,7 @@ void InitRefrigeration(EnergyPlusData &state) } } - // Accumulative and carry-over variables are not zeroed at start of each time step, only at begining of environment + // Accumulative and carry-over variables are not zeroed at start of each time step, only at beginning of environment if (state.dataGlobal->BeginEnvrnFlag && state.dataRefrigCase->InitRefrigerationMyBeginEnvrnFlag) { if (state.dataRefrigCase->NumSimulationCases > 0) { for (int i = RefrigCase.l(), e = RefrigCase.u(); i <= e; ++i) { @@ -10811,7 +10811,7 @@ void RefrigRackData::CalcRackSystem(EnergyPlusData &state) // In that subroutine, dispatch coils within each set in order specified for each zone // Below will assign loads to refrigeration system or secondary loop // Note that this routine will go through all refrigeration systems, but loads for multiple systems - // with interactions will not be known for the intital calls with first HVAC time step. They will, + // with interactions will not be known for the initial calls with first HVAC time step. They will, // however, be repeated when the last chiller set is called from ZoneEquipmentManager // that's why important where init goes, don't want to zero out data should keep if (state.dataRefrigCase->UseSysTimeStep) { @@ -11505,7 +11505,7 @@ void RefrigCaseData::CalculateCase(EnergyPlusData &state) // Absolute pointer to ShowContinueError(state, " Total Cooling Capacity."); } else { ShowContinueError(state, - " This case has insufficient capacity to meet excess energy associated with a zone enviroment temperature " + " This case has insufficient capacity to meet excess energy associated with a zone environment temperature " "greater than the design ambient for the case."); ShowContinueError(state, " Refer to documentation for further explanation of "); ShowContinueError(state, " Total Cooling Capacity."); @@ -11517,7 +11517,7 @@ void RefrigCaseData::CalculateCase(EnergyPlusData &state) // Absolute pointer to ShowContinueError(state, " recommendations regarding Total Cooling Capacity, Sensible Heat Ratio, and Defrost Capacity."); } else { ShowContinueError(state, - " This case has insufficient capacity to meet excess energy associated with a zone enviroment temperature " + " This case has insufficient capacity to meet excess energy associated with a zone environment temperature " "greater than the design ambient for the case."); ShowContinueError(state, " Refer to documentation for further explanation of "); ShowContinueError(state, " Total Cooling Capacity."); @@ -11954,7 +11954,7 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) // In that subroutine, dispatch coils within each set in order specified for each zone // Below will assign loads to refrigeration system or secondary loop // Note that this routine will go through all refrigeration systems, but loads for multiple systems - // with interactions will not be known for the intital calls with first HVAC time step. They will, + // with interactions will not be known for the initial calls with first HVAC time step. They will, // however, be repeated when the last chiller set is called from ZoneEquipmentManager // that's why important where init goes, don't want to zero out data should keep if (state.dataRefrigCase->UseSysTimeStep) { @@ -12233,7 +12233,7 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) "of the refrigeration loads, ", thisSys.HiStageWarnIndex1); ShowRecurringContinueErrorAtEnd( - state, " subcooler loads (if any), and low-stage compressor loads for this sytem.", thisSys.HiStageWarnIndex2); + state, " subcooler loads (if any), and low-stage compressor loads for this system.", thisSys.HiStageWarnIndex2); } // Hi-stage capacity<(load+LSHX load + lo-stage compressor load) } // CoilFlag (Numcoils > 0) and load > capacity @@ -12273,7 +12273,7 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) if (state.dataRefrigCase->ShowUnmetEnergyWarning(SysNum)) { ShowWarningError(state, format("Refrigeration:System: {}", thisSys.Name)); ShowContinueError(state, " The specified compressors for this system are unable to meet "); - ShowContinueError(state, " the sum of the refrigerated case loads and subcooler loads (if any) for this sytem."); + ShowContinueError(state, " the sum of the refrigerated case loads and subcooler loads (if any) for this system."); state.dataRefrigCase->ShowUnmetEnergyWarning(SysNum) = false; } // show warning } // > mylarge number @@ -12283,7 +12283,7 @@ void SimulateDetailedRefrigerationSystems(EnergyPlusData &state) ShowWarningError(state, format("Refrigeration:System: {}", thisSys.Name)); ShowContinueError(state, " The specified high-stage compressors for this system are unable to meet "); ShowContinueError(state, " the sum of the refrigerated case loads, subcooler loads (if any) and "); - ShowContinueError(state, " low-stage compressor loads for this sytem."); + ShowContinueError(state, " low-stage compressor loads for this system."); state.dataRefrigCase->ShowHiStageUnmetEnergyWarning(SysNum) = false; } // show warning } // > mylarge number @@ -12530,7 +12530,7 @@ void SimulateDetailedTransRefrigSystems(EnergyPlusData &state) if (state.dataRefrigCase->ShowUnmetEnergyWarningTrans(SysNum)) { ShowWarningError(state, format("Refrigeration:TranscriticalSystem: {}", sys.Name)); ShowContinueError(state, " The specified compressors for this system are unable to meet "); - ShowContinueError(state, " the sum of the refrigerated case loads and subcooler loads (if any) for this sytem."); + ShowContinueError(state, " the sum of the refrigerated case loads and subcooler loads (if any) for this system."); state.dataRefrigCase->ShowUnmetEnergyWarningTrans(SysNum) = false; } // show warning } // > mylarge number @@ -12895,7 +12895,7 @@ void RefrigSystemData::CalculateCondensers(EnergyPlusData &state, int const SysN // 'spectacular' icing problems. Ideally, the user will use the evaporative schedule input // to set such a schedule. However, sometimes, users will use a single input deck to model // one building in multiple climates, and may not think to put in such a schedule in the colder - // climates. To accomodate such applications, the variable EvapCutOutTdb is used as an extra + // climates. To accommodate such applications, the variable EvapCutOutTdb is used as an extra // check. if (OutDbTemp < EvapCutOutTdb) EvapAvail = false; @@ -12989,7 +12989,7 @@ void RefrigSystemData::CalculateCondensers(EnergyPlusData &state, int const SysN } break; case FanSpeedCtrlType::TwoSpeed: { // low speed setting of 1/2 fan speed can give up to 60% of capacity. - // 1/2 speed corresonds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) + // 1/2 speed corresponds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) // dampers are used to control flow within those two ranges as in FanConstantSpeed Real64 const air_vol_fan_power_fac(std::exp(1.0 - AirVolRatio) * RatedFanPower); ActualFanPower = AirVolRatio * air_vol_fan_power_fac; @@ -13256,7 +13256,7 @@ void TransRefrigSystemData::CalcGasCooler(EnergyPlusData &state, int const SysNu } break; case FanSpeedCtrlType::TwoSpeed: { // low speed setting of 1/2 fan speed can give up to 60% of capacity. - // 1/2 speed corresonds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) + // 1/2 speed corresponds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) // dampers are used to control flow within those two ranges as in FanConstantSpeed ActualFanPower = AirVolRatio * std::exp(1.0 - AirVolRatio) * RatedFanPower; if (CapFac < CapFac60Percent) ActualFanPower = ((AirVolRatio + 0.4) * (FanHalfSpeedRatio)) * std::exp(1.0 - AirVolRatio) * RatedFanPower; @@ -13551,7 +13551,7 @@ void RefrigSystemData::CalculateCompressors(EnergyPlusData &state) compressor.Capacity = CapacityCorrection * Curve::CurveValue(state, compressor.CapacityCurvePtr, TsatforPsuct, TsatforPdisch); compressor.MassFlow = compressor.Capacity / TotalEnthalpyChangeActual; - // calculate load factor for last compressor addded + // calculate load factor for last compressor added // assumes either cycling or part load eff = full load eff for last compressor if (StageIndex == 1) { // Single-stage or low-stage compressors if ((this->TotCompCapacity + compressor.Capacity) >= NeededCapacity) { @@ -13650,7 +13650,7 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) // REFERENCES: // ANSI/AHRI. 2004. Standard 540, Standard for Performance Rating of Positive Displacement Refrigerant - // Comprssors and Compressor Units. Arlington, VA: Air-Conditioning, Heating, and Refrigeration + // Compressors and Compressor Units. Arlington, VA: Air-Conditioning, Heating, and Refrigeration // Institute. // Ge, Y.T., and S.A. Tassou. 2011. Performance evaluation and optimal design of supermarket refrigeration // systems with supermarket model "SuperSim", Part I: Model description and validation. International @@ -13689,8 +13689,8 @@ void TransRefrigSystemData::CalculateTransCompressors(EnergyPlusData &state) Real64 HGCOutlet; // Enthalpy at gas cooler outlet, J/kg Real64 HIdeal; // Ideal enthalpy at subcooler (for 100% effectiveness) Real64 HsatLiqforTevapNeededMT; // Enthalpy of saturated liquid at MT evaporator, J/kg - Real64 HsatVaporforTevapneededMT; // Enthlapy of saturated vapor at MT evaporator (transcritical cycle), J/kg - Real64 HsatVaporforTevapneededLT; // Enthlapy of saturated vapor at LT evaporator (transcritical cycle), J/kg + Real64 HsatVaporforTevapneededMT; // Enthalpy of saturated vapor at MT evaporator (transcritical cycle), J/kg + Real64 HsatVaporforTevapneededLT; // Enthalpy of saturated vapor at LT evaporator (transcritical cycle), J/kg Real64 LFLastComp; // Load factor for last compressor dispatched Real64 MassCorrectionLT; // Mass flow at existing subcool/superheat over cap at rated conditions for LT loads Real64 MassCorrectionMT; // Mass flow at existing subcool/superheat over cap at rated conditions for MT loads @@ -14385,7 +14385,7 @@ void ReportRefrigerationComponents(EnergyPlusData &state) } //((NumSimulationSubcoolers - NumSimulationMechSubcoolers) > 0) if (state.dataRefrigCase->NumTransRefrigSystems > 0) { - print(state.files.eio, "{}\n", Format_120); // Intro to detailed transcriticial refrigeration system + print(state.files.eio, "{}\n", Format_120); // Intro to detailed transcritical refrigeration system print(state.files.eio, "{}\n", Format_121); // Detailed system header if (state.dataRefrigCase->NumSimulationCases > 0) { print(state.files.eio, "{}\n", Format_105); // Case header @@ -15146,7 +15146,7 @@ void WalkInData::CalculateWalkIn(EnergyPlusData &state) // Absolute pointer to MassDryAirRate * (HumRatioZoneAir - HumRatioAirWalkIn); // Walk in cooler removes water at this rate in this zone (kg/s) // Just as with cases, we assume no latent credit (water removal = 0) to zone or load on cooler during dripdown // To be consistent with the treatment of refrigerated cases, latent load - // and latent credit are bothbased on reducing the infiltrating vapor to ice. (This is + // and latent credit are both based on reducing the infiltrating vapor to ice. (This is // slightly greater than if the latent credit were based upon condensing out the water as liquid.) // then it would be: ZoneLatentLoad = -WaterRemovRate * WaterToVaporEnthalpy * (1.0d0-DefrostDripDownSchedule) ZoneLatentLoad = -WaterRemovRate * IcetoVaporEnthalpy * (1.0 - DefrostDripDownSchedule); @@ -15513,7 +15513,7 @@ void SecondaryLoopData::CalculateSecondary(EnergyPlusData &state, int const Seco int CoilID = this->CoilNum(CoilIndex); // already CALL CalculateCoil(CoilID) for each coil, dispatched in coilset order for each zone // increment TotalCoolingLoad for each system - // here will find out if secondary can serve total load, if not will derate coil outout/case credits + // here will find out if secondary can serve total load, if not will derate coil output/case credits RefrigerationLoad += WarehouseCoil(CoilID).TotalCoolingLoad; TotalHotDefrostCondCredit += WarehouseCoil(CoilID).HotDefrostCondCredit; } // NumCoils on secondary system @@ -16234,7 +16234,7 @@ void WarehouseCoilData::CalculateCoil(EnergyPlusData &state, Real64 const QZnReq } break; case FanSpeedCtrlType::TwoSpeed: { // low speed setting of 1/2 fan speed can give up to 60% of capacity. - // 1/2 speed corresonds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) + // 1/2 speed corresponds to ~1/8 power consumption (FanHalfSpeedRatio = 1/(2**2.5) = 0.1768) // dampers are used to control flow within those two ranges as in FanConstantSpeed if (CapFac < CapFac60Percent) { FanPowerActual = ((AirVolRatio + 0.4) * (FanHalfSpeedRatio)) * std::exp(1.0 - AirVolRatio) * FanPowerMax; diff --git a/src/EnergyPlus/SZVAVModel.cc b/src/EnergyPlus/SZVAVModel.cc index 854b944ecff..2e378cb3f02 100644 --- a/src/EnergyPlus/SZVAVModel.cc +++ b/src/EnergyPlus/SZVAVModel.cc @@ -165,13 +165,13 @@ namespace SZVAVModel { // model attempts to control air flow rate and coil capacity in specific operating regions: // Region 1 (R1) - minimum air flow rate at modulated coil capacity (up to min/max temperature limits) - // Region 2 (R2) - modultated air flow rate and coil capacity (up to max air flow rate while maintaining min/max temperature limits) + // Region 2 (R2) - modulated air flow rate and coil capacity (up to max air flow rate while maintaining min/max temperature limits) // Region 3 (R3) - maximum air flow rate and modulated/increased coil capacity (allow increased capacity at full air flow rate to meet // remaining load) // // | | | | ^ ^ = supply air temperature // | | | | ^ * = supply air flow rate - // | | |^^^^| <--- maximum supply air temperture + // | | |^^^^| <--- maximum supply air temperature // | | ^ | | // | | ^ | | // ***********| | ^ | |************** <-- max unit air flow rate @@ -333,7 +333,7 @@ namespace SZVAVModel { } } else { // not enough capacity at this air flow rate. Unit does have enough capacity a full water/air, otherwise wouldn't be here // this is different from the PTUnit and UnitarySys routines in this module - // find the water flow rate that meets the min load at region 1/2 bounday + // find the water flow rate that meets the min load at region 1/2 boundary if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) { auto f = // (AUTO_OK_LAMBDA) [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode, maxCoilFluidFlow, minAirMassFlow]( @@ -630,13 +630,13 @@ namespace SZVAVModel { // model attempts to control air flow rate and coil capacity in specific operating regions: // Region 1 (R1) - minimum air flow rate at modulated coil capacity (up to min/max temperature limits) - // Region 2 (R2) - modultated air flow rate and coil capacity (up to max air flow rate while maintaining min/max temperature limits) + // Region 2 (R2) - modulated air flow rate and coil capacity (up to max air flow rate while maintaining min/max temperature limits) // Region 3 (R3) - maximum air flow rate and modulated/increased coil capacity (allow increased capacity at full air flow rate to meet // remaining load) // // | | | | ^ ^ = supply air temperature // | | | | ^ * = supply air flow rate - // | | |^^^^| <--- maximum supply air temperture + // | | |^^^^| <--- maximum supply air temperature // | | ^ | | // | | ^ | | // ***********| | ^ | |************** <-- max unit air flow rate diff --git a/src/EnergyPlus/ScheduleManager.cc b/src/EnergyPlus/ScheduleManager.cc index 83184a58b25..3a3d17350ab 100644 --- a/src/EnergyPlus/ScheduleManager.cc +++ b/src/EnergyPlus/ScheduleManager.cc @@ -1510,7 +1510,7 @@ namespace ScheduleManager { ErrorsFound = true; } ++NumField; - Alphas(UntilFld + xxcount) = Alphas(NumField); // Incase next is "until" + Alphas(UntilFld + xxcount) = Alphas(NumField); // In case next is "until" } else { ShowSevereError(state, format("{}{}=\"{}\", Looking for \"Until\" field, found={}", @@ -2719,7 +2719,7 @@ namespace ScheduleManager { return 0.0; } else if (!state.dataScheduleMgr->Schedule(ScheduleIndex).EMSActuatedOn) { return state.dataScheduleMgr->Schedule(ScheduleIndex) - .CurrentValue; // This block probably unecessary, UpdateScheduleValues already does it + .CurrentValue; // This block probably unnecessary, UpdateScheduleValues already does it } else { return state.dataScheduleMgr->Schedule(ScheduleIndex).EMSValue; } @@ -4579,7 +4579,7 @@ namespace ScheduleManager { for (int jType = 1; jType <= maxDayTypes; ++jType) { if (dayTypeFilter[jType - 1]) { auto &daySch = state.dataScheduleMgr->DaySchedule(weekSch.DaySchedulePointer(jType)); - // use precalcuated min and max from SetScheduleMinMax + // use precalculated min and max from SetScheduleMinMax MinValue = min(MinValue, daySch.TSValMin); MaxValue = max(MaxValue, daySch.TSValMax); } diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc index 4f5808e0f65..916a84cb646 100644 --- a/src/EnergyPlus/SimulationManager.cc +++ b/src/EnergyPlus/SimulationManager.cc @@ -1372,11 +1372,11 @@ namespace SimulationManager { // unused0909743 Format(' Display Extra Warnings',2(', ',A)) // ENDIF if (state.dataGlobal->createPerfLog) { - writeIntialPerfLogValues(state, overrideModeValue); + writeInitialPerfLogValues(state, overrideModeValue); } } - void writeIntialPerfLogValues(EnergyPlusData &state, std::string const ¤tOverrideModeValue) + void writeInitialPerfLogValues(EnergyPlusData &state, std::string const ¤tOverrideModeValue) // write the input related portions of the .perflog // J.Glazer February 2020 { diff --git a/src/EnergyPlus/SimulationManager.hh b/src/EnergyPlus/SimulationManager.hh index 86f23c4a5d7..7fd0146c9f5 100644 --- a/src/EnergyPlus/SimulationManager.hh +++ b/src/EnergyPlus/SimulationManager.hh @@ -64,7 +64,7 @@ namespace SimulationManager { void GetProjectData(EnergyPlusData &state); - void writeIntialPerfLogValues(EnergyPlusData &state, std::string const ¤tOverrideModeValue); + void writeInitialPerfLogValues(EnergyPlusData &state, std::string const ¤tOverrideModeValue); std::string bool_to_string(bool logical); diff --git a/src/EnergyPlus/SizingAnalysisObjects.cc b/src/EnergyPlus/SizingAnalysisObjects.cc index ee6eb9d8ab8..1ab21946264 100644 --- a/src/EnergyPlus/SizingAnalysisObjects.cc +++ b/src/EnergyPlus/SizingAnalysisObjects.cc @@ -128,7 +128,7 @@ int SizingLog::GetZtStepIndex(const ZoneTimestepObject tmpztStepStamp) vecIndex = envrnStartZtStepIndexMap[newEnvrnToSeedEnvrnMap[tmpztStepStamp.envrnNum]]; } - // next for safety sake, constrain index to lie inside correct envronment + // next for safety sake, constrain index to lie inside correct environment if (vecIndex < envrnStartZtStepIndexMap[newEnvrnToSeedEnvrnMap[tmpztStepStamp.envrnNum]]) { vecIndex = envrnStartZtStepIndexMap[newEnvrnToSeedEnvrnMap[tmpztStepStamp.envrnNum]]; // first step in environment } @@ -538,7 +538,7 @@ void PlantCoinicidentAnalysis::ResolveDesignFlowRate(EnergyPlusData &state, int } } - // add a seperate eio summary report about what happened, did demand trap get used, what were the key values. + // add a separate eio summary report about what happened, did demand trap get used, what were the key values. if (!state.dataGlobal->sizingAnalysisEioHeaderDoneOnce) { print(state.files.eio, "{}", diff --git a/src/EnergyPlus/SizingManager.cc b/src/EnergyPlus/SizingManager.cc index 0b76cbd122e..a6e7b85e5a5 100644 --- a/src/EnergyPlus/SizingManager.cc +++ b/src/EnergyPlus/SizingManager.cc @@ -118,7 +118,7 @@ void ManageSizing(EnergyPlusData &state) // DATE WRITTEN December 2000 // PURPOSE OF THIS SUBROUTINE: - // This subroutine manages the sizing simulations (using design day condiions) + // This subroutine manages the sizing simulations (using design day conditions) // for zones, central air systems, and central plants and zone heating and cooling // METHODOLOGY EMPLOYED: @@ -172,7 +172,7 @@ void ManageSizing(EnergyPlusData &state) GetZoneAirDistribution(state); // get zone air distribution objects GetZoneHVACSizing(state); // get zone HVAC sizing object GetAirTerminalSizing(state); // get air terminal sizing object - GetSizingParams(state); // get the building level sizing paramets + GetSizingParams(state); // get the building level sizing parameters GetZoneSizingInput(state); // get the Zone Sizing input GetSystemSizingInput(state); // get the System Sizing input GetPlantSizingInput(state); // get the Plant Sizing input @@ -988,7 +988,7 @@ void ManageSystemSizingAdjustments(EnergyPlusData &state) state.dataPowerInductionUnits->PIU(pIUATUNum).MaxPriAirVolFlow; state.dataSize->VdzClgByZone(termUnitSizingIndex) = state.dataPowerInductionUnits->PIU(pIUATUNum) - .MaxPriAirVolFlow; // for Parallel PIU expect Fan off durign max cooling, so discharge is all primary + .MaxPriAirVolFlow; // for Parallel PIU expect Fan off during max cooling, so discharge is all primary state.dataSize->VdzMinClgByZone(termUnitSizingIndex) = state.dataPowerInductionUnits->PIU(pIUATUNum).MinPriAirFlowFrac * state.dataPowerInductionUnits->PIU(pIUATUNum).MaxPriAirVolFlow + @@ -1278,7 +1278,7 @@ void ManageSystemVentilationAdjustments(EnergyPlusData &state) } // Fill Vps for cooling VRP calculation, use cooling design flow rate as adjusted in ManageSystemSizingAdjustments ( to use - // conincident sizing result if available for block air flow + // coincident sizing result if available for block air flow state.dataSize->VpsClgBySys(AirLoopNum) = FinalSysSizing(AirLoopNum).DesCoolVolFlow; // Fill Vps for heating VRP calculation, use heating min by zone from air terminal scan in ManageSystemSizingAdjustments @@ -1422,7 +1422,7 @@ void ManageSystemVentilationAdjustments(EnergyPlusData &state) // redo VpzClgSumBySys( AirLoopNum ) with latest values, for reporting state.dataSize->VpzClgSumBySys(AirLoopNum) = 0.0; // Fill Vps for cooling VRP calculation, use cooling design flow rate as adjusted in ManageSystemSizingAdjustments ( to use - // conincident sizing result if available for block air flow + // coincident sizing result if available for block air flow state.dataSize->VpsClgBySys(AirLoopNum) = FinalSysSizing(AirLoopNum).DesCoolVolFlow; // Fill Vps for heating VRP calculation, use heating min by zone from air terminal scan in ManageSystemSizingAdjustments state.dataSize->VpsHtgBySys(AirLoopNum) = 0.0; @@ -2119,7 +2119,7 @@ void DetermineSystemPopulationDiversity(EnergyPlusData &state) format("{:02}/{:02} {:02}:{:02}", Month, DayOfMonth, TimeHrsInt, TimeMinsInt); state.dataSize->PeakPsOccurrenceEnvironmentStringBySys(AirLoopNum) = "Full Year Schedule"; } - } // if autosizied and VRP + } // if autosized and VRP } // air loops } } @@ -3334,7 +3334,7 @@ void GetZoneSizingInput(EnergyPlusData &state) ShowWarningError( state, format("{} = \"{}\", maximum value ({}%) of Zone Humidistat Humidification Set Point Schedule Name = {} is " - "greater than minimum value ({}%) of Zone Humidistat Dehumidifcation Set Point Schedule Name = {}. " + "greater than minimum value ({}%) of Zone Humidistat Dehumidification Set Point Schedule Name = {}. " "Humidification set point will be limited by Dehumidification set point during zone sizing and simulation " "continues.", cCurrentModuleObject, @@ -3369,7 +3369,7 @@ void ReportTemperatureInputError( state.dataIPShortCut->rNumericArgs(paramNum - 2))); ShowContinueError(state, "This is not allowed. Please check and revise your input."); ErrorsFound = true; - } else { // then input is lower than comparison tempeature--just produce a warning for user to check input + } else { // then input is lower than comparison temperature--just produce a warning for user to check input ShowWarningError(state, format("{}=\"{}\" has invalid data.", cObjectName, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError(state, format("... incorrect {}=[{:.2R}] is less than [{:.2R}]", @@ -4438,7 +4438,7 @@ void reportZoneSizingEio(EnergyPlusData &state, // SUBROUTINE INFORMATION: // AUTHOR Fred Buhl - // DATE WRITTEN Decenber 2001 + // DATE WRITTEN December 2001 // MODIFIED August 2008, Greg Stark // PURPOSE OF THIS SUBROUTINE: @@ -4613,12 +4613,12 @@ void GetZoneHVACSizing(EnergyPlusData &state) int iCoolCAPMAlphaNum; // get input index to Zone HVAC sizing chilled water flow method int iCoolDesignCapacityNumericNum; // get input index to Zone HVAC sizing chilled water flow int iCoolCapacityPerFloorAreaNumericNum; // get input index to Zone HVAC sizing cooling capacity per floor area - int iCoolFracOfAutosizedCapacityNumericNum; // get input index to Zone HVAC sizing capacity as fraction autozized cooling capacity + int iCoolFracOfAutosizedCapacityNumericNum; // get input index to Zone HVAC sizing capacity as fraction autosized cooling capacity int iHeatCAPMAlphaNum; // get input index to Zone HVAC sizing heating capacity int iHeatDesignCapacityNumericNum; // get input index to Zone HVAC sizing heating design capacity int iHeatCapacityPerFloorAreaNumericNum; // get input index to Zone HVAC sizing heating capacity per floor area - int iHeatFracOfAutosizedCapacityNumericNum; // get input index to Zone HVAC sizing capacity as fraction autozized cooling capacity + int iHeatFracOfAutosizedCapacityNumericNum; // get input index to Zone HVAC sizing capacity as fraction autosized cooling capacity iCoolSAFMAlphaNum = 2; // get input index to Zone HVAC sizing heat supp air flow method iMaxCoolAirVolFlowNumericNum = 1; // get input index to Zone HVAC sizing cool supply air flow @@ -4646,7 +4646,7 @@ void GetZoneHVACSizing(EnergyPlusData &state) iHeatCAPMAlphaNum = 6; // get input index to Zone HVAC sizing heating capacity iHeatDesignCapacityNumericNum = 16; // get input index to Zone HVAC sizing heating design capacity iHeatCapacityPerFloorAreaNumericNum = 17; // get input index to Zone HVAC sizing heating capacity per floor area - iHeatFracOfAutosizedCapacityNumericNum = 18; // get input index to Zone HVAC sizing capacity as fraction autozized heating capacity + iHeatFracOfAutosizedCapacityNumericNum = 18; // get input index to Zone HVAC sizing capacity as fraction autosized heating capacity int NumAlphas; // Number of Alphas for each GetObjectItem call int NumNumbers; // Number of Numbers for each GetObjectItem call @@ -5007,7 +5007,7 @@ void GetZoneHVACSizing(EnergyPlusData &state) ShowContinueError(state, format("Illegal {} = Autosize", cNumericFields(iNoCoolHeatFlowPerFracCoolNumericNum))); ErrorsFound = true; } else { - // user input frcation of cooling supply air flow rate during no cooling or heating area is saved in + // user input fraction of cooling supply air flow rate during no cooling or heating area is saved in // ZoneHVACSizing(zSIndex).MaxNoCoolHeatAirVolFlow state.dataSize->ZoneHVACSizing(zSIndex).RequestAutoSize = true; } @@ -5037,7 +5037,7 @@ void GetZoneHVACSizing(EnergyPlusData &state) ShowContinueError(state, format("Illegal {} = Autosize", cNumericFields(iNoCoolHeatFlowPerFracHeatNumericNum))); ErrorsFound = true; } else { - // user input frcation of heating supply air flow rate during no cooling or heating area is saved in + // user input fraction of heating supply air flow rate during no cooling or heating area is saved in // ZoneHVACSizing(zSIndex).MaxNoCoolHeatAirVolFlow state.dataSize->ZoneHVACSizing(zSIndex).RequestAutoSize = true; } @@ -5278,7 +5278,7 @@ void GetAirTerminalSizing(EnergyPlusData &state) } } -// Update the sizing for the entire facilty to gather values for reporting - Glazer January 2017 +// Update the sizing for the entire facility to gather values for reporting - Glazer January 2017 void UpdateFacilitySizing([[maybe_unused]] EnergyPlusData &state, Constant::CallIndicator const CallIndicator) { int NumOfTimeStepInDay = state.dataGlobal->NumOfTimeStepInHour * 24; diff --git a/src/EnergyPlus/SolarCollectors.cc b/src/EnergyPlus/SolarCollectors.cc index 20efa9010b7..6699a75c382 100644 --- a/src/EnergyPlus/SolarCollectors.cc +++ b/src/EnergyPlus/SolarCollectors.cc @@ -464,7 +464,7 @@ namespace SolarCollectors { ShowSevereError(state, format("{} = {}", CurrentModuleParamObject, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError( state, format("Illegal {} = {:.2R}", state.dataIPShortCut->cNumericFieldNames(1), state.dataIPShortCut->rNumericArgs(1))); - ShowContinueError(state, " Collector gross area must be always gretaer than zero."); + ShowContinueError(state, " Collector gross area must be always greater than zero."); ErrorsFound = true; } state.dataSolarCollectors->Parameters(ParametersNum).Volume = state.dataIPShortCut->rNumericArgs(2); @@ -472,7 +472,7 @@ namespace SolarCollectors { ShowSevereError(state, format("{} = {}", CurrentModuleParamObject, state.dataIPShortCut->cAlphaArgs(1))); ShowContinueError( state, format("Illegal {} = {:.2R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2))); - ShowContinueError(state, " Collector water volume must be always gretaer than zero."); + ShowContinueError(state, " Collector water volume must be always greater than zero."); ErrorsFound = true; } // Note: this value is used to calculate the heat loss through the bottom and side of the collector @@ -517,7 +517,7 @@ namespace SolarCollectors { } // Solar absorptance of the absorber plate state.dataSolarCollectors->Parameters(ParametersNum).AbsorOfAbsPlate = state.dataIPShortCut->rNumericArgs(16); - // thermal emmissivity of the absorber plate + // thermal emissivity of the absorber plate state.dataSolarCollectors->Parameters(ParametersNum).EmissOfAbsPlate = state.dataIPShortCut->rNumericArgs(17); } // end of ParametersNum @@ -977,8 +977,8 @@ namespace SolarCollectors { this->CosTilt = std::cos(Tilt * Constant::DegToRadians); this->SinTilt = std::sin(1.8 * Tilt * Constant::DegToRadians); - // Diffuse reflectance of the cover for solar radiation diffusely reflected back from the absober - // plate to the cover. The diffuse solar radiation reflected back from the absober plate to the + // Diffuse reflectance of the cover for solar radiation diffusely reflected back from the absorber + // plate to the cover. The diffuse solar radiation reflected back from the absorber plate to the // cover is represented by the 60 degree equivalent incident angle. This diffuse reflectance is // used to calculate the transmittance - absorptance product (Duffie and Beckman, 1991) Real64 Theta = 60.0 * Constant::DegToRadians; @@ -1660,7 +1660,7 @@ namespace SolarCollectors { // DATE WRITTEN February 2012 // PURPOSE OF THIS SUBROUTINE: - // Calculates the transmitance, reflectance, and absorptance of the collector covers based on + // Calculates the transmittance, reflectance, and absorptance of the collector covers based on // solar collector optical parameters specified. // METHODOLOGY EMPLOYED: @@ -1692,7 +1692,7 @@ namespace SolarCollectors { AbsCover1 = 0.0; AbsCover2 = 0.0; - bool DiffRefFlag; // flag for calc. diffuse refl of cover from inside to outsidd + bool DiffRefFlag; // flag for calc. diffuse refl of cover from inside to outside if (present(InOUTFlag)) { DiffRefFlag = InOUTFlag; } else { @@ -2036,9 +2036,9 @@ namespace SolarCollectors { // PURPOSE OF THIS FUNCTION: // Calculates the free convection coefficient between the absorber plate and water. // METHODOLOGY EMPLOYED: - // The convection coefficient calculation were based on the Fujii and Imura emperical correlations + // The convection coefficient calculation were based on the Fujii and Imura empirical correlations // REFERENCES: - // T.Fujii, and H.Imura,Natural convection heat transfer from aplate with arbitrary inclination. + // T.Fujii, and H.Imura,Natural convection heat transfer from a plate with arbitrary inclination. // International Journal of Heat and Mass Transfer: 15(4), (1972), 755-764. Real64 hConvA2W; // convection coefficient, [W/m2K] diff --git a/src/EnergyPlus/SolarShading.cc b/src/EnergyPlus/SolarShading.cc index 9aa58438b76..9ffe7a922e9 100644 --- a/src/EnergyPlus/SolarShading.cc +++ b/src/EnergyPlus/SolarShading.cc @@ -2707,7 +2707,7 @@ void CHKBKS(EnergyPlusData &state, // correspond to how CHKBKS is called // Jan 2002, FW: change error message // RE-ENGINEERED Lawrie, Oct 2000 - // Sep 2020: Revised the vector computation method to reliabily produce CVec, + // Sep 2020: Revised the vector computation method to reliably produce CVec, // and simplified the warning messages. // PURPOSE OF THIS SUBROUTINE: @@ -3071,7 +3071,7 @@ void CHKSBS(EnergyPlusData &state, // CALL ShowContinueError(state, 'Surface "'//TRIM(Surface(GRSNR)%Name)//'" '//TRIM(MSG(OverlapStatus))// & // ' SubSurface "'//TRIM(Surface(SBSNR)%Name)//'"') // IF (FirstSurroundError) THEN - // CALL ShowWarningError(state, 'Base Surface does not surround subsurface errors occuring...'// & + // CALL ShowWarningError(state, 'Base Surface does not surround subsurface errors occurring...'// & // 'Check that the SurfaceGeometry object is expressing the proper starting corner and '// & // 'direction [CounterClockwise/Clockwise]') // FirstSurroundError=.FALSE. @@ -4155,7 +4155,7 @@ void CLIPRECT(EnergyPlusData &state, int const NS2, int const NV1, int &NV3) } } - // update homogenous edges A,B,C + // update homogeneous edges A,B,C if (NV3 > 0) { Real64 const X_0(state.dataSolarShading->XTEMP[0]); Real64 const Y_0(state.dataSolarShading->YTEMP[0]); @@ -5894,7 +5894,7 @@ void SHDGSS(EnergyPlusData &state, int NS1; // Number of the figure being overlapped int NS2; // Number of the figure doing overlapping int NS3; // Location to place results of overlap - Real64 SchValue; // Value for Schedule of shading transmittence + Real64 SchValue; // Value for Schedule of shading transmittance auto &s_surf = state.dataSurface; @@ -5943,7 +5943,7 @@ void SHDGSS(EnergyPlusData &state, } } } - // Elimate shawdowing surfaces that is supposed to be disabled. + // Eliminate shadowing surfaces that is supposed to be disabled. if (state.dataSysVars->DisableAllSelfShading) { if (surface.Zone != 0) { continue; // Disable all shadowing surfaces in all zones. Attached shading surfaces are not part of a zone, zone value is 0. @@ -6844,11 +6844,11 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } else if (s_surf->SurfWinWindowModelType(SurfNum) == WindowModel::EQL) { // call the ASHWAT fenestration model for optical properties - // determine the beam radiation absorptance and tranmittance of the + // determine the beam radiation absorptance and transmittance of the // the equivalent layer window model WindowEquivalentLayer::CalcEQLOpticalProperty(state, SurfNum, SolarArrays::BEAM, state.dataSolarShading->SurfWinAbsSolBeamEQL); auto &CFS = state.dataWindowEquivLayer->CFS; - // recalcuate the diffuse absorptance and transmittance of the + // recalculate the diffuse absorptance and transmittance of the // the equivalent layer window model if there is shade control int EQLNum = state.dataConstruction->Construct(surf.Construction).EQLConsPtr; // equivalent layer fenestration index if (CFS(EQLNum).ISControlled) { @@ -7128,7 +7128,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) if (ShadeFlag == WinShadingType::IntBlind) { Real64 RhoBlBmDifFr = FrontBeamDiffRefl; // Beam-diffuse front reflectance of blind Real64 RGlDifBk = thisConstruct.ReflectSolDiffBack; // Diffuse front reflectance of glass - Real64 RhoBlDifDifFr = FrontDiffDiffRefl; // Diffuse-diffuse front refectance of blind + Real64 RhoBlDifDifFr = FrontDiffDiffRefl; // Diffuse-diffuse front reflectance of blind // beam-beam and diffuse transmittance of exterior beam TBmBmBl = TBmBm * TBlBmBm; TBlDifDif = FrontDiffDiffTrans; @@ -7139,7 +7139,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) if (TBmDifShBlSc < 0.0) TBmDifShBlSc = 0.0; } else if (ShadeFlag == WinShadingType::ExtBlind) { Real64 RhoBlBmDifBk = BackBeamDiffRefl; // Beam-diffuse back reflectance of blind - Real64 RhoBlDifDifBk = BackDiffDiffRefl; // Diffuse-diffuse back refectance of blind + Real64 RhoBlDifDifBk = BackDiffDiffRefl; // Diffuse-diffuse back reflectance of blind Real64 RGlBmFr = POLYF(CosInc, thisConstruct.ReflSolBeamFrontCoef); Real64 RGlDifFr = thisConstruct.ReflectSolDiffFront; // beam-beam and diffuse transmittance of exterior beam @@ -7879,7 +7879,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) CFBoverlap = 0.0; // Calculate effects on all back surfaces for each of basis directions. Each of basis directions from the back of the - // window has to be considered as beam and therefore calcualte CFBoverlap for each of them + // window has to be considered as beam and therefore calculate CFBoverlap for each of them for (int CurTrnDir = 1; CurTrnDir <= state.dataBSDFWindow->ComplexWind(SurfNum).Geom(CurCplxFenState).Trn.NBasis; ++CurTrnDir) { Real64 CurLambda = state.dataBSDFWindow->ComplexWind(SurfNum) @@ -7916,7 +7916,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) CurTrnDir <= state.dataBSDFWindow->ComplexWind(SurfNum).Geom(CurCplxFenState).Trn.NBasis; ++CurTrnDir) { Real64 bestDot; // complex fenestration hits other complex fenestration, it is important to find - // matching beam directions. Beam leving one window will have certaing number for it's basis + // matching beam directions. Beam leaving one window will have certain number for it's basis // while same beam reaching back surface will have different beam number. This value is used // to keep best matching dot product for those directions Real64 curDot; // temporary variable for current dot product @@ -8040,7 +8040,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) Real64 backSurfBeamSolInTrans = 0.0; // Fraction of BeamSolarRad transmitted out through window inside face [W] // Interior beam absorptance of glass layers and beam transmittance of back exterior & - // or interior window (treates windows with/without shades as defined) for this timestep + // or interior window (treats windows with/without shades as defined) for this timestep // call the ASHWAT fenestration model for beam radiation here WindowEquivalentLayer::CalcEQLOpticalProperty( @@ -8493,8 +8493,8 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) int CurrentState = s_surf->SurfaceWindow(SurfNum).ComplexFen.CurrentState; auto &cplxState = s_surf->SurfaceWindow(SurfNum).ComplexFen.State(CurrentState); for (size_t Lay = 1; Lay <= numOfLayers; ++Lay) { - // Simon: Imporant note about this equation is to use BeamSolarRad and not SurfQRadSWOutIncident - // is becuase BeamSolarRad is direct normal radiation (looking at the Sun) while SurfRadSWOutIncident + // Simon: Important note about this equation is to use BeamSolarRad and not SurfQRadSWOutIncident + // is because BeamSolarRad is direct normal radiation (looking at the Sun) while SurfRadSWOutIncident // is normal to window incidence. Since BSDF coefficients are taking into account angle of incidence, // BeamSolarRad should be used in this case state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) = @@ -8837,7 +8837,7 @@ void SHDRVL(EnergyPlusData &state, // REFERENCES: // BLAST/IBLAST code, original author George Walton - int NVS; // Number of verticies + int NVS; // Number of vertices int constexpr None(0); // for use with RevealStatus int constexpr EntireWindowShadedByReveal(1); // for use with RevealStatus @@ -8950,7 +8950,7 @@ void SHDRVL(EnergyPlusData &state, state.dataSolarShading->YVS(N) = s_surf->ShadeV(SBSNR).YV(NVS + 1 - N); } - // Transform to homogenous coordinates + // Transform to homogeneous coordinates NS2 = state.dataSolarShading->LOCHCA + 1; state.dataSolarShading->LOCHCA = NS2; @@ -9410,7 +9410,7 @@ void WindowShadingManager(EnergyPlusData &state) POLYF(1.0, state.dataConstruction->Construct(IConst).TransVisBeamCoef) * surfWin.glazedFrac; // Window has shading control - // select the active window shading control and corresponding contructions + // select the active window shading control and corresponding constructions size_t indexWindowShadingControl = selectActiveWindowShadingControlIndex(state, ISurf); if (!s_surf->Surface(ISurf).windowShadingControlList.empty() && indexWindowShadingControl <= s_surf->Surface(ISurf).windowShadingControlList.size() - 1) { @@ -9910,7 +9910,7 @@ void WindowShadingManager(EnergyPlusData &state) slatAng = Constant::DegToRad * surfShade.blind.slatAngDegEMSValue; } - // Slat angle is changing, need to recalcualte stored values + // Slat angle is changing, need to recalculate stored values if (slatAng != surfShade.blind.slatAng) { surfShade.blind.slatAng = slatAng; surfShade.blind.slatAngDeg = surfShade.blind.slatAng * Constant::RadToDeg; @@ -9944,7 +9944,7 @@ void WindowShadingManager(EnergyPlusData &state) } // End of check if interior or exterior or between glass blind in place // AR: don't need to do this anymore I don't think - // CALL CalcScreenTransmittance to intialized all screens prior to HB calc's + // CALL CalcScreenTransmittance to initialized all screens prior to HB calc's // if (s_surf->SurfWinShadingFlag(ISurf) == WinShadingType::ExtScreen && state.dataEnvrn->SunIsUp) { // CalcScreenTransmittance(state, ISurf); // } @@ -11117,7 +11117,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) DiffReflGlass = Window::InterpSw(s_surf->SurfWinSwitchingFactor(SurfNum), DiffReflGlass, DiffReflGlassSh); } - // Calc beam solar sbsorbed (m2) + // Calc beam solar absorbed (m2) s_surf->SurfWinBmSolAbsdInsReveal(SurfNum) += A2ill * SolTransGlass * InsideRevealSolAbs * CosBeta * tmp_SunlitFracWithoutReveal; @@ -12556,7 +12556,7 @@ void CalcComplexWindowOverlap(EnergyPlusData &state, // HTRANS routine is using coordinates stored in XVS and YVS in order to calculate // surface area. Since both projections are equal to zero, then simply - // compy these values into XVS and YVS arrays + // copy these values into XVS and YVS arrays for (N = 1; N <= NVT; ++N) { state.dataSolarShading->XVS(N) = state.dataSolarShading->XVertex(N); state.dataSolarShading->YVS(N) = state.dataSolarShading->YVertex(N); @@ -12569,7 +12569,7 @@ void CalcComplexWindowOverlap(EnergyPlusData &state, for (IRay = 1; IRay <= Geom.Trn.NBasis; ++IRay) { // basis directions loop (on back surface) // For current basis direction calculate dot product between window surface // and basis direction. This will be used to calculate projection of each - // of the back surfaces to window surface for given basis direciton + // of the back surfaces to window surface for given basis direction SdotX = dot(s_surf->Surface(ISurf).lcsx, Geom.sTrn(IRay)); SdotY = dot(s_surf->Surface(ISurf).lcsy, Geom.sTrn(IRay)); SdotZ = dot(s_surf->Surface(ISurf).lcsz, Geom.sTrn(IRay)); @@ -12577,7 +12577,7 @@ void CalcComplexWindowOverlap(EnergyPlusData &state, YSp = -SdotY; ZSp = -SdotZ; - // Projection of shadows for current basis direciton + // Projection of shadows for current basis direction if (std::abs(ZSp) > Constant::SmallDistance) { XShadowProjection = XSp / ZSp; YShadowProjection = YSp / ZSp; @@ -12634,12 +12634,12 @@ void CalcComplexWindowOverlap(EnergyPlusData &state, Geom.AOverlap(KBkSurf, IRay) = state.dataSolarShading->HCAREA(state.dataSolarShading->LOCHCA); } // DO KBkSurf = 1 , NBkSurf - // If some of back surfaces is contained in base surface, then need to substract shadow of subsurface - // from shadow on base surface. Reson is that above shadowing algorithm is calculating shadow wihtout + // If some of back surfaces is contained in base surface, then need to subtract shadow of subsurface + // from shadow on base surface. Reason is that above shadowing algorithm is calculating shadow without // influence of subsurfaces for (KBkSurf = 1; KBkSurf <= Window.NBkSurf; ++KBkSurf) { // back surf loop BackSurfaceNumber = state.dataShadowComb->ShadowComb(BaseSurf).BackSurf(KBkSurf); - // CurBaseSurf is Current base surface number for shadow overlap calcualtions + // CurBaseSurf is Current base surface number for shadow overlap calculations int CurBaseSurf = s_surf->Surface(BackSurfaceNumber).BaseSurf; if (CurBaseSurf != BackSurfaceNumber) { // Search if that base surface in list of back surfaces for current window diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc index 4f5a85f8348..6d43fbcdd2c 100644 --- a/src/EnergyPlus/StandardRatings.cc +++ b/src/EnergyPlus/StandardRatings.cc @@ -444,13 +444,13 @@ namespace StandardRatings { Real64 COPReduced(0.0); // COP at reduced capacity test conditions (100%, 75%, 50%, and 25%) Real64 LoadFactor(0.0); // Fractional "on" time for last stage at the desired reduced capacity, // (dimensionless) - Real64 DegradationCoeff(0.0); // Degradation coeficient, (dimenssionless) + Real64 DegradationCoeff(0.0); // Degradation coefficient, (dimensionless) Real64 ChillerCapFT_rated(0.0); // Chiller capacity fraction at AHRI rated conditions (evaluated as a function of temperature) Real64 ChillerCapFT(0.0); // Chiller capacity fraction (evaluated as a function of temperature) Real64 ChillerEIRFT_rated(0.0); // Chiller electric input ratio (EIR = 1 / COP) at AHRI rated conditions as a function of temperature Real64 ChillerEIRFT(0.0); // Chiller electric input ratio (EIR = 1 / COP) as a function of temperature Real64 ChillerEIRFPLR(0.0); // Chiller EIR as a function of part-load ratio (PLR) - Real64 PartLoadRatio(0.0); // Part load ratio (PLR) at which chiller is operatign at reduced capacity + Real64 PartLoadRatio(0.0); // Part load ratio (PLR) at which chiller is operating at reduced capacity int RedCapNum; // Integer counter for reduced capacity int SolFla; // Flag of solver @@ -780,7 +780,7 @@ namespace StandardRatings { } } - // Note: We don't want unit conversio, here, but it's ok since W/W will convert to itself since the column heading has "SI" as a hint + // Note: We don't want unit conversion, here, but it's ok since W/W will convert to itself since the column heading has "SI" as a hint PreDefTableEntry(state, state.dataOutRptPredefined->pdchMechIPLVSI, ChillerName, IPLVValueSI, 2); PreDefTableEntry(state, state.dataOutRptPredefined->pdchMechIPLVIP, ChillerName, IPLVValueIP, 2); } @@ -973,18 +973,18 @@ namespace StandardRatings { // (1) Obtains the rated condition parameters: // heating capacity (User specified or Autosized Value), COP, Rated Air volume flow rate through the // DX Cooling Coil (User specified or autosized value) and Fan power per rated air flow rate - // (2) Evaluates the heating coil capacities for AHRI tests H1, H2 and H3 using the performance cuves and + // (2) Evaluates the heating coil capacities for AHRI tests H1, H2 and H3 using the performance curves and // input values specified at (1) above. Then net heating capacity is determined from the total heating capacity // of the DX coil at the AHRI test conditions and accounting for the INDOOR supply air fan heat. // (3) Calculates the electric power consumed by the DX Coil Unit (compressor + outdoor condenser fan). // The net electric power consumption is determined by adding the indoor fan electric power to the // electric power consumption by the DX Coil Condenser Fan and Compressor at the AHRI test conditions. // (4) High Temperature Heating Standard (Net) Rating Capacity and Low Temperature Heating Standard (Net) - // Rating Capacity capacity are determined using tests H1 adn H3 per ANSI/AHRI 210/240 2008. + // Rating Capacity capacity are determined using tests H1 and H3 per ANSI/AHRI 210/240 2008. // (5) The HSPF is evaluated from the total net heating capacity and total electric power // evaluated at the standard rated test conditions. For user specified region number, the outdoor temperatures - // are Binned (grouped) and fractioanl bin hours for each bin over the entire heating season are taken - // from AHRI 210/240. Then for each bin, building load, heat pump energy adn resistance space heating enegry are + // are Binned (grouped) and fractional bin hours for each bin over the entire heating season are taken + // from AHRI 210/240. Then for each bin, building load, heat pump energy and resistance space heating energy are // calculated. The sum of building load divided by sum of heat pump and resistance space heating over the // entire heating season gives the HSPF. The detailed calculation algorithms of calculating HSPF // are described in Engineering Reference. @@ -998,14 +998,14 @@ namespace StandardRatings { // conditions and accounting for the INDOOR supply air fan effect. The net total cooling capacity // is reported at the high (maximum) speed only. // (3) Calculates the electric power consumed by the DX Coil Unit (compressor + outdoor condenser fan). - // Evaluates the EIR capacity and flow fraction modifiers at A2, B2, B1, and F1 test coditions per + // Evaluates the EIR capacity and flow fraction modifiers at A2, B2, B1, and F1 test conditions per // AHRI/ANSI Std. 210/240 test procedure for multi-speed compressor. For any inter- - // mediate operating conditions (speed), the successive lower and the higher speed performnace are + // mediate operating conditions (speed), the successive lower and the higher speed performance are // weighed per the standard. Electric Power consumption is determined by adding the indoor fan // electric power to the electric power consumption by the outdoor DX Coil Fan and Compressor Power // at the AHRI test conditions. The net total cooling capacity is also corrected for the fan heat // effect for SEER calculation. - // Net Heatingg Capacity and HSPF + // Net Heating Capacity and HSPF // (4) Obtains the rated condition parameters: // Heating capacity (User specified or Autosized Value) // Rated Air volume flow rate through the DX Heating Coil (User specified or autosized value) @@ -1017,7 +1017,7 @@ namespace StandardRatings { // Evaluates the EIR capacity and flow fraction modifiers per AHRI/ANSI Std. 210/240 test procedures // for two speed compressor (H01, H11, H21, H31, H12, H22, and H32 ). This procedure was modified // for multispeed heat pumps. For any inter-mediate operating conditions (speed), the successive - // lower and the higher speed performnace are weighed per the standard. + // lower and the higher speed performance are weighed per the standard. // Electric Power consumption is determined by adding the supply fan electric power to the electric // power consumption by the outdoor DX Coil Fan and Compressor Power at the AHRI test conditions. // The net heating capacity is also corrected for the fan heat effect for SEER calculation. @@ -1078,14 +1078,14 @@ namespace StandardRatings { Real64 SEER_User(0.0); // Seasonal Energy Efficiency Ratio using user PLF curve in SI [W/W] Real64 SEER_Standard(0.0); // Seasonal Energy Efficiency Ratio using AHRI 210/240 PLF default curve & C_D in SI [W/W] Real64 EER(0.0); // Energy Efficiency Ratio using AHRI 210-240 2017 in SI [W/W] - Real64 IEER(0.0); // Integerated Energy Efficiency Ratio in SI [W/W] + Real64 IEER(0.0); // Integrated Energy Efficiency Ratio in SI [W/W] // SEER2 ANSI/AHRI 210/240 Standard 2023 Ratings Real64 SEER2_User(0.0); // Seasonal Energy Efficiency Ratio using user PLF curve in SI [W/W] Real64 SEER2_Standard(0.0); // Seasonal Energy Efficiency Ratio using AHRI 210/240 PLF default curve & C_D in SI [W/W] Real64 EER2(0.0); // Energy Efficiency Ratio using AHRI 210/140 - 2023 Real64 EER_2022(0.0); // Energy Efficiency Ratio in SI [W/W] - Real64 IEER_2022(0.0); // Integerated Energy Efficiency Ratio in SI [W/W] + Real64 IEER_2022(0.0); // Integrated Energy Efficiency Ratio in SI [W/W] Real64 HSPF(0.0); // Heating Seasonal Performance Factor in SI [W/W] Real64 NetHeatingCapRatedHighTemp(0.0); // Net Rated heating capacity at high temp [W] @@ -1366,7 +1366,7 @@ namespace StandardRatings { EIRFFlowCurveIndex(spnum), PLFFPLRCurveIndex(spnum)); } - // Calculate Net heatig capacity and HSPF & HSPF2 of multispeed DX heating coils + // Calculate Net heating capacity and HSPF & HSPF2 of multispeed DX heating coils std::map StandardRatingsResult = MultiSpeedDXHeatingCoilStandardRatings(state, DXCoilName, DXCoilType, @@ -1530,7 +1530,7 @@ namespace StandardRatings { Real64 NetCoolingCapRatedMaxSpeed2023(0.0); // net cooling capacity at maximum speed Real64 EER_2022(0.0); // Energy Efficiency Ratio in SI [W/W] - Real64 IEER_2022(0.0); // Integerated Energy Efficiency Ratio in SI [W/W] + Real64 IEER_2022(0.0); // Integrated Energy Efficiency Ratio in SI [W/W] Real64 NetCoolingCapRated2022(0.0); Real64 EER(0.0); @@ -1626,7 +1626,7 @@ namespace StandardRatings { Real64 NetCoolingCapRatedMaxSpeed2023(0.0); // net cooling capacity at maximum speed Real64 EER_2022(0.0); // Energy Efficiency Ratio in SI [W/W] - Real64 IEER_2022(0.0); // Integerated Energy Efficiency Ratio in SI [W/W] + Real64 IEER_2022(0.0); // Integrated Energy Efficiency Ratio in SI [W/W] Real64 NetCoolingCapRated2022(0.0); int constexpr ns = 2; @@ -1770,7 +1770,7 @@ namespace StandardRatings { // entire heating season [W] Real64 PartLoadFactor; Real64 LowTempCutOutFactor(0.0); // Factor which corresponds to compressor operation depending on outdoor temperature - Real64 OATempCompressorOff(0.0); // Minimum outdoor air temperature to turn the commpressor off, [C] + Real64 OATempCompressorOff(0.0); // Minimum outdoor air temperature to turn the compressor off, [C] Real64 HSPF(0.0); if (RegionNum == 5) { @@ -1896,7 +1896,7 @@ namespace StandardRatings { Real64 HeatingModeLoadFactor2023(0.0); // HSPF2 Heating mode load factor corresponding to an outdoor bin temperature [-] Real64 PartLoadFactor2023; Real64 CheckCOP2023(0.0); // HSPF2 Checking COP at an outdoor bin temperature against unity [-] - Real64 OATempCompressorOff2023(0.0); // HSPF2 Minimum outdoor air temperature to turn the commpressor off, [C] + Real64 OATempCompressorOff2023(0.0); // HSPF2 Minimum outdoor air temperature to turn the compressor off, [C] Real64 LowTempCutOutFactor2023(0.0); // Factor which corresponds to compressor operation depending on outdoor temperature Real64 HeatPumpElectricalEnergy2023(0.0); // HSPF2 Heatpump electrical energy corresponding to an outdoor bin temperature [W] Real64 ResistiveSpaceHeatingElectricalEnergy2023(0.0); // HSPF2 resistance heating electrical energy corresponding to an @@ -2009,12 +2009,12 @@ namespace StandardRatings { { Real64 NetHeatingCapRated(0.0); // Net Heating Coil capacity at Rated conditions, Real64 NetHeatingCapH3Test(0.0); // Net Heating Coil capacity at H3 test conditions - Real64 HSPF(0.0); // seasonale energy efficiency ratio of multi speed DX cooling coil + Real64 HSPF(0.0); // seasonal energy efficiency ratio of multi speed DX cooling coil // ANSI/AHRI 210/240 Standard 2023 Real64 NetHeatingCapRated_2023(0.0); // Net Heating Coil capacity at Rated conditions, Real64 NetHeatingCapH3Test_2023(0.0); // Net Heating Coil capacity at H3 test conditions - Real64 HSPF2_2023(0.0); // seasonale energy efficiency ratio of multi speed DX cooling coil + Real64 HSPF2_2023(0.0); // seasonal energy efficiency ratio of multi speed DX cooling coil Real64 IEER_2022(0.0); std::map StandardRatingsResults; // SUBROUTINE INFORMATION: @@ -2056,15 +2056,15 @@ namespace StandardRatings { // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 TotalHeatingCapRated(0.0); // Heating Coil capacity at Rated conditions, without accounting supply fan heat [W] Real64 EIRRated(0.0); // EIR at Rated conditions [-] - Real64 TotCapTempModFacRated(0.0); // Total capacity as a function of temerature modifier at rated conditions [-] - Real64 EIRTempModFacRated(0.0); // EIR as a function of temerature modifier at rated conditions [-] + Real64 TotCapTempModFacRated(0.0); // Total capacity as a function of temperature modifier at rated conditions [-] + Real64 EIRTempModFacRated(0.0); // EIR as a function of temperature modifier at rated conditions [-] Real64 TotalHeatingCapH2Test(0.0); // Heating Coil capacity at H2 test conditions, without accounting supply fan heat [W] Real64 TotalHeatingCapH3Test(0.0); // Heating Coil capacity at H3 test conditions, without accounting supply fan heat [W] - Real64 CapTempModFacH2Test(0.0); // Total capacity as a function of temerature modifier at H2 test conditions [-] - Real64 EIRTempModFacH2Test(0.0); // EIR as a function of temerature modifier at H2 test conditions [-] + Real64 CapTempModFacH2Test(0.0); // Total capacity as a function of temperature modifier at H2 test conditions [-] + Real64 EIRTempModFacH2Test(0.0); // EIR as a function of temperature modifier at H2 test conditions [-] Real64 EIRH2Test(0.0); // EIR at H2 test conditions [-] - Real64 CapTempModFacH3Test(0.0); // Total capacity as a function of temerature modifier at H3 test conditions [-] - Real64 EIRTempModFacH3Test(0.0); // EIR as a function of temerature modifier at H3 test conditions [-] + Real64 CapTempModFacH3Test(0.0); // Total capacity as a function of temperature modifier at H3 test conditions [-] + Real64 EIRTempModFacH3Test(0.0); // EIR as a function of temperature modifier at H3 test conditions [-] Real64 EIRH3Test(0.0); // EIR at H3 test conditions [-] Real64 TotCapFlowModFac(0.0); // Total capacity modifier (function of actual supply air flow vs rated flow) Real64 EIRFlowModFac(0.0); // EIR modifier (function of actual supply air flow vs rated flow) @@ -2291,10 +2291,10 @@ namespace StandardRatings { Real64 EIRTempModFac(0.0); // EIR modifier (function of entering wetbulb, outside drybulb) [-] Real64 EIR(0.0); // Energy Efficiency Ratio at AHRI test conditions for SEER [-] Real64 LoadFactor(0.0); // Fractional "on" time for last stage at the desired reduced capacity, (dimensionless) - Real64 DegradationCoeff(0.0); // Degradation coeficient, (dimenssionless) + Real64 DegradationCoeff(0.0); // Degradation coefficient, (dimensionless) Real64 ElecPowerReducedCap(0.0); // Net power consumption (Cond Fan+Compressor) at reduced test condition [W] Real64 EERReduced(0.0); // EER at reduced capacity test conditions (100%, 75%, 50%, and 25%) - Real64 IEER = 0.0; // Integareted energy efficiency ratio of single speed DX cooling coil + Real64 IEER = 0.0; // Integrated energy efficiency ratio of single speed DX cooling coil Real64 NetCoolingCapRated = 0.0; // net cooling capacity of single speed DX cooling coil // Calculate the net cooling capacity at the rated conditions (19.44C WB and 35.0C DB ) diff --git a/src/EnergyPlus/SteamBaseboardRadiator.cc b/src/EnergyPlus/SteamBaseboardRadiator.cc index aa6203b7481..7a94e57896d 100644 --- a/src/EnergyPlus/SteamBaseboardRadiator.cc +++ b/src/EnergyPlus/SteamBaseboardRadiator.cc @@ -287,7 +287,7 @@ namespace SteamBaseboardRadiator { int constexpr iHeatCapacityPerFloorAreaNumericNum( 1); // get input index to steam baseboard Radiator system electric heating capacity per floor area sizing int constexpr iHeatFracOfAutosizedCapacityNumericNum( - 2); // get input index to steam baseboard Radiator system electric heating capacity sizing as fraction of autozized heating capacity + 2); // get input index to steam baseboard Radiator system electric heating capacity sizing as fraction of autosized heating capacity // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int BaseboardNum; // Baseboard number @@ -318,7 +318,7 @@ namespace SteamBaseboardRadiator { state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign); state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign); - // Get the data from the user input related to baseboard heater designobjects + // Get the data from the user input related to baseboard heater design objects for (BaseboardDesignNum = 1; BaseboardDesignNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign; ++BaseboardDesignNum) { state.dataInputProcessing->inputProcessor->getObjectItem(state, @@ -901,7 +901,7 @@ namespace SteamBaseboardRadiator { // This subroutine initializes the baseboard units. // METHODOLOGY EMPLOYED: - // The initialization subrotines both in high temperature radiant radiator + // The initialization subroutines both in high temperature radiant radiator // and convective only baseboard radiator are combined and modified. // The heater is assumed to be crossflow with both fluids unmixed. @@ -1232,7 +1232,7 @@ namespace SteamBaseboardRadiator { state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID, "Design Size Maximum Steam Flow Rate [m3/s]", SteamVolFlowRateMaxDes, - "User-Speicified Maximum Steam Flow Rate [m3/s]", + "User-Specified Maximum Steam Flow Rate [m3/s]", SteamVolFlowRateMaxUser); if (state.dataGlobal->DisplayExtraWarnings) { // Report difference between design size and user-specified values @@ -1256,7 +1256,7 @@ namespace SteamBaseboardRadiator { } } else { if (IsAutoSize) { - // if there is no heating Sizing:Plant object and autosizng was requested, issue an error message + // if there is no heating Sizing:Plant object and autosizing was requested, issue an error message // first error will be issued by MyPlantSizingIndex ShowSevereError(state, "Autosizing of steam baseboard requires a heating loop Sizing:Plant object"); ShowContinueError(state, @@ -1413,7 +1413,7 @@ namespace SteamBaseboardRadiator { // PURPOSE OF THIS SUBROUTINE: // METHODOLOGY EMPLOYED: - // The update subrotines both in high temperature radiant radiator + // The update subroutines both in high temperature radiant radiator // and convective only baseboard radiator are combined and modified. using PlantUtilities::SafeCopyPlantNode; @@ -1497,7 +1497,7 @@ namespace SteamBaseboardRadiator { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // To distribute the gains from the steam basebaord heater + // To distribute the gains from the steam baseboard heater // as specified in the user input file. This includes distribution // of long wavelength radiant gains to surfaces and "people." diff --git a/src/EnergyPlus/SurfaceGeometry.cc b/src/EnergyPlus/SurfaceGeometry.cc index 51eb490b07a..91213614f9c 100644 --- a/src/EnergyPlus/SurfaceGeometry.cc +++ b/src/EnergyPlus/SurfaceGeometry.cc @@ -1786,7 +1786,7 @@ namespace SurfaceGeometry { ++state.dataSurfaceGeometry->ErrCount2; if (state.dataSurfaceGeometry->ErrCount2 == 1 && !state.dataGlobal->DisplayExtraWarnings) { ShowWarningError(state, - format("{}CAUTION -- Interspace surfaces are occuring in the same space(s).", RoutineName)); + format("{}CAUTION -- Interspace surfaces are occurring in the same space(s).", RoutineName)); ShowContinueError( state, "...use Output:Diagnostics,DisplayExtraWarnings; to show more details on individual occurrences."); } @@ -4275,7 +4275,7 @@ namespace SurfaceGeometry { state.dataSurfaceGeometry->SurfaceTmp(i).Name, state.dataSurfaceGeometry->SurfaceTmp(i).ExtBoundCondName)); ErrorsFound = true; - // If vertex size mistmatch + // If vertex size mismatch } else if (state.dataSurfaceGeometry->SurfaceTmp(i).Vertex.size() != state.dataSurfaceGeometry->SurfaceTmp(ExtSurfNum).Vertex.size()) { ShowSevereError(state, @@ -4642,7 +4642,7 @@ namespace SurfaceGeometry { s_ipsc->cCurrentModuleObject, state.dataSurfaceGeometry->SurfaceTmp(SurfNum).Name, state.dataSurfaceGeometry->SurfaceTmp(SurfNum).Height)); - ShowContinueError(state, "..which deos not match its construction height."); + ShowContinueError(state, "..which does not match its construction height."); } } @@ -7383,7 +7383,7 @@ namespace SurfaceGeometry { int IOStat; // IO Status when calling get input subroutine int NumAlpha; // Number of alpha names being passed int NumProp; // Number of properties being passed - int TotShadingSurfaceReflectance; // Total Shading Surface Refleftance statements + int TotShadingSurfaceReflectance; // Total Shading Surface Reflectance statements int Loop; // DO loop index int SurfNum; // Surface number int GlConstrNum; // Glazing construction number @@ -7484,7 +7484,7 @@ namespace SurfaceGeometry { // Write reflectance values to .eio file. print(state.files.eio, "! ,Shading Surface Name,Shading Type,Diffuse Solar Reflectance, Diffuse " - "Visible Reflectance,Surface Glazing Fraction,Surface Glazing Contruction\n"); + "Visible Reflectance,Surface Glazing Fraction,Surface Glazing Construction\n"); for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { auto const &surf = state.dataSurface->Surface(SurfNum); @@ -7730,7 +7730,7 @@ namespace SurfaceGeometry { if (ErrorsFound) continue; // previous inner do loop may have detected problems that need to be cycle'd again to avoid crash - // now that we should have all the surfaces, do some preperations and checks. + // now that we should have all the surfaces, do some preparations and checks. // are they all similar tilt and azimuth? Issue warnings so people can do it if they really want Real64 const surfaceArea(sum_sub(state.dataSurface->Surface, &SurfaceData::Area, state.dataHeatBal->ExtVentedCavity(Item).SurfPtrs)); @@ -9273,7 +9273,7 @@ namespace SurfaceGeometry { // na // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - int Ptr; // Pointer into Vertice array + int Ptr; // Pointer into Vertices array int n; // Loop counter int NSrc; // Used for CW -> CCW transformation int NTar; // Used for CW -> CCW transformation @@ -10307,7 +10307,7 @@ namespace SurfaceGeometry { state.dataSurfaceGeometry->SurfaceTmp(SurfNum).shadedConstructionList.push_back(curShadedConstruction); state.dataSurfaceGeometry->SurfaceTmp(SurfNum).activeShadedConstruction = curShadedConstruction; - // check to make the window refenced is an exterior window + // check to make the window referenced is an exterior window if (state.dataSurfaceGeometry->SurfaceTmp(SurfNum).ExtBoundCond != ExternalEnvironment) { ErrorsFound = true; ShowSevereError( @@ -11591,7 +11591,7 @@ namespace SurfaceGeometry { // \units hr // \default 24 // N9, \field Previous Other Side Temperature Coefficient - // \note This coeffient multiplies the other side temperature result from the + // \note This coefficient multiplies the other side temperature result from the // \note previous zone timestep // \type real // \default 0 @@ -13785,7 +13785,7 @@ namespace SurfaceGeometry { int ConstrNewSt = Util::FindItemInList(ConstrNameSt, state.dataConstruction->Construct, state.dataHeatBal->TotConstructs); // Number of unshaded storm window construction that is created - // If necessary, create new material corresponding to the air layer between the storm winddow and the rest of the window + // If necessary, create new material corresponding to the air layer between the storm window and the rest of the window int MatNewStAir = createAirMaterialFromDistance(state, state.dataSurface->StormWindow(StormWinNum).StormWinDistance, "AIR:STORMWIN:"); if (ConstrNewSt == 0) { ConstrNewSt = createConstructionWithStorm( @@ -13828,7 +13828,7 @@ namespace SurfaceGeometry { ChrNum; // Name of shaded construction with storm window int ConstrNewStSh = createConstructionWithStorm( state, ConstrNum, ConstrNameStSh, state.dataSurface->StormWindow(StormWinNum).StormWinMaterialNum, MatNewStAir); - surf.shadedStormWinConstructionList[iConstruction] = ConstrNewStSh; // put in same index as the shaded constuction + surf.shadedStormWinConstructionList[iConstruction] = ConstrNewStSh; // put in same index as the shaded construction } } // end of loop for shaded constructions } // end of loop over storm window objects @@ -13993,7 +13993,7 @@ namespace SurfaceGeometry { // Locals // SUBROUTINE ARGUMENT DEFINITIONS: - // If there is a second glazing systme on the Data File, SurfNum+1 + // If there is a second glazing system on the Data File, SurfNum+1 // has the construction of the second glazing system. // 2-glazing system Window5 data file entry @@ -14163,7 +14163,7 @@ namespace SurfaceGeometry { // Locals // SUBROUTINE ARGUMENT DEFINITIONS: - // If there is a second glazing systme on the Data File, SurfNum+1 + // If there is a second glazing system on the Data File, SurfNum+1 // has the construction of the second glazing system. // 2-glazing system Window5 data file entry @@ -14762,7 +14762,7 @@ namespace SurfaceGeometry { Real64 Tri2Area(AreaPolygon(3, Triangle2) / TotalArea); // check if sum of fractions are slightly greater than 1.0 which is a symptom of the triangles for a non-convex - // quadralateral using the wrong two triangles + // quadrilateral using the wrong two triangles if ((Tri1Area + Tri2Area) > 1.05) { // if so repeat the process with the other two possible triangles (notice the vertices are in a different order this @@ -14864,7 +14864,7 @@ namespace SurfaceGeometry { // METHODOLOGY EMPLOYED: // Mine solar renewables input and collect surface names. // find shading surfaces with names that match those in solar objects. - // setup flags for shading surfaces so that the solar renewables can resuse incident solar calcs + // setup flags for shading surfaces so that the solar renewables can reuse incident solar calcs // new solar component models that use shading surfaces will have to extend the code here. // Using/Aliasing @@ -15644,7 +15644,7 @@ namespace SurfaceGeometry { Real64 WidthEff; // Effective width of the surface Real64 WidthMax; // X difference between the vertex on the most left and the one on the most right Real64 HeightEff; // Effective height of the surface - Real64 HeightMax; // Y difference between the lowest and toppest vertices + Real64 HeightMax; // Y difference between the lowest and highest vertices Real64 Xp; Real64 Yp; Real64 Zp; diff --git a/src/EnergyPlus/TARCOGArgs.cc b/src/EnergyPlus/TARCOGArgs.cc index 33df57c9608..1267a4894dc 100644 --- a/src/EnergyPlus/TARCOGArgs.cc +++ b/src/EnergyPlus/TARCOGArgs.cc @@ -421,7 +421,7 @@ int ArgCheck(EnergyPlusData &state, for (int i = 1; i <= nlayer; ++i) { if (scon(i) <= 0.0) { ArgCheck = 26; - ErrorMessage = format("Layer {:3} has conductivity whcih is less or equal to zero.", i); + ErrorMessage = format("Layer {:3} has conductivity which is less or equal to zero.", i); return ArgCheck; } @@ -491,7 +491,7 @@ int ArgCheck(EnergyPlusData &state, if (presure(i) < 0.0) { ArgCheck = 27; if ((i == 1) || (i == (nlayer + 1))) { - ErrorMessage = "One of enviroments (inside or outside) has pressure which is less than zero."; + ErrorMessage = "One of environments (inside or outside) has pressure which is less than zero."; } else { ErrorMessage = format("One of gaps has pressure which is less than zero. Gap #{:3}", i); } diff --git a/src/EnergyPlus/TARCOGMain.cc b/src/EnergyPlus/TARCOGMain.cc index 3b07d1d8c6b..56fcdb71a37 100644 --- a/src/EnergyPlus/TARCOGMain.cc +++ b/src/EnergyPlus/TARCOGMain.cc @@ -68,22 +68,22 @@ namespace EnergyPlus::TARCOGMain { // MODIFIED na // RE-ENGINEERED (see information bellow) // Revision: 7.0.13 (March/27/2012), Simon Vidanovic -// - feature: New set of equaitons is set instead of hhat coefficents and new approach to solution which improves +// - feature: New set of equations is set instead of hhat coefficients and new approach to solution which improves // speed and stability. Note that this solution does not include laminates // Revision: 7.0.12 (March/06/2012), Simon Vidanovic // - feature: Additional state for isky introduced. Tarcog now can accept IR radiance from external source. // Revision: 7.0.11 (January/04/2012), Simon Vidanovic -// - imrovements/bug fixes: Several items merged from Windows tarcog version into this one: -// - bug fix: Correct foramtting for VacuumMaxGapThickness when program writes input file +// - improvements/bug fixes: Several items merged from Windows tarcog version into this one: +// - bug fix: Correct formatting for VacuumMaxGapThickness when program writes input file // - improvement: Gamma coefficient is now written in scientific notation (needed for correct output file generation) -// - imporvement: Gap data are now saved with higer precision to wincog input file (test purposes, debug mode only) +// - improvement: Gap data are now saved with higher precision to wincog input file (test purposes, debug mode only) // - bug fix: Gap temperatures are recalculated within iterations (for thermally driven and forced ventilation) // Revision: 7.0.10 (December/15/2011), Simon Vidanovic -// - imrovement: Flag for performing SHGC calculations +// - improvement: Flag for performing SHGC calculations // Revision: 7.0.09 (November/15/2011), Simon Vidanovic -// - imrovement: Added error message tolerance (This is necessary to handle error messages in correct way) +// - improvement: Added error message tolerance (This is necessary to handle error messages in correct way) // Revision: 7.0.08 (November/15/2011), Simon Vidanovic -// - bug fix: Fixed program crashing when warrning message 1007 occurred (output could not fit in string) +// - bug fix: Fixed program crashing when warning message 1007 occurred (output could not fit in string) // - feature: relaxation parameter changed // Revision: 7.0.07 (November/08/2011), Simon Vidanovic // - feature: Error message (as string) is now return from tarcog @@ -92,7 +92,7 @@ namespace EnergyPlus::TARCOGMain { // Revision: 7.0.05 (November/07/2011), Simon Vidanovic // - bug fix: Troom and Tamb are not passed out of hhat routine after recalculation is performed. // This will cause differences in calculation of U-factor -// - feature: VacuumMaxGapThickness is added to list of input paramters +// - feature: VacuumMaxGapThickness is added to list of input parameters // Revision: 7.0.04 (November/03/2011), Simon Vidanovic // - bug fix: one of debug files did not update properly // Revision: 7.0.03 (November/01/2011), Simon Vidanovic @@ -133,7 +133,7 @@ namespace EnergyPlus::TARCOGMain { // - Added new input argument - SDScalar: // 0.0 - No SD (in terms of convection) // 1.0 - Closed SD (SD treated as a 'regular' specular layer) -// between 0 and 1 - cobination of No SD and Closed SD cases +// between 0 and 1 - combination of No SD and Closed SD cases // - A bug in unshaded run (remapping gas properties in removal of indoor SD layer) was fixed // - TARCOG error codes have been updated (error codes 30 and 37 added) // Revision: 6.0.26 (May/31/2006) @@ -169,7 +169,7 @@ namespace EnergyPlus::TARCOGMain { // - Added two new output arguments needed for connection with T6: // HcUnshadedOut, // HcUnshadeIn. -// - Changed the way ShadeHcRatioOut and ShadeHcRatioIn are caculated. +// - Changed the way ShadeHcRatioOut and ShadeHcRatioIn are calculated. // Revision: 6.0.21 (October/28/2005) // - Fixed another serious bug in new routine for calculation of U factor. // Revision: 6.0.20 (October/20/2005) @@ -185,7 +185,7 @@ namespace EnergyPlus::TARCOGMain { // - Description of arguments has been updated. // - Forced ventilation calc has been disabled. // Revision: 6.0.18 (September/16/2005) -// - Changed Tvent for outdoor and indoor SD layers to Tout and Tin, respectivelly. +// - Changed Tvent for outdoor and indoor SD layers to Tout and Tin, respectively. // - Keff is now calculated for each gap. // Revision: 6.0.17 (September/08/2005) // - Fixed a bug involving Al, Ar & Ah values (patch for a case of Al+Ar+Ah = 0). @@ -210,7 +210,7 @@ namespace EnergyPlus::TARCOGMain { // - Minor change in Picard coefficients for vented gaps - MaxIter cannot // be less than 800. This solves issue with theta buffer in Therm1d. // - Implemented creation of TARCOG debug file w/ i/o arguments/results (Tarcog.dbg) -// (fetaure #8); debug file will be created depending on Debug_mode switch: +// (feature #8); debug file will be created depending on Debug_mode switch: // Debug_mode = 0 : debug file will not be created // Debug_mode = 1 : debug file will be appended // Debug_mode = 2 : new debug file will be created @@ -256,14 +256,14 @@ namespace EnergyPlus::TARCOGMain { // - implemented arrays for ventilation temperature and speed // - repaired equation 121 in ISO (instead of cos(tilt) now is ABS(cos(tilt))) // - implemented input field for forced ventilation velocity (for all cases) -// - fixed bug in shading edge: coefficients B1, C1 and D1 repaired to calcluate value for gap temperature (not enviroment) -// - fixed bug in routine shading edge: characteristic Height is calculated for gap (not for enviroment) -// - fixed bug in proccesing error messages (this was produced slightly wrong in some cases results) +// - fixed bug in shading edge: coefficients B1, C1 and D1 repaired to calculate value for gap temperature (not environment) +// - fixed bug in routine shading edge: characteristic Height is calculated for gap (not for environment) +// - fixed bug in processing error messages (this was produced slightly wrong in some cases results) // Revision: 6.0.06 rv (04/22/03) // - write out heat flux calculation for shading device panes // - qv smoothing: make vented heat flux same in adjacent gaps (gaps are divided by shading pane) // - fixed bug in routine "shadingin": make that vented heat flow direction is calculated correct, according -// to temeratures in adjecent gaps +// to temperatures in adjacent gaps // Revision: 6.0.05 (04/14/03) // - implemented "Picard" method in iteration loop // - number of iterations is increased to 1000 @@ -360,8 +360,8 @@ void TARCOG90(EnergyPlusData &state, Real64 const VacuumPressure, // maximal pressure for gas to be considered as vacuum Real64 &VacuumMaxGapThickness, // maximum allowed thickness without producing warning message DeflectionCalculation const CalcDeflection, // Deflection calculation flag: - Real64 const Pa, // Atmospheric (outside/inside) pressure (used onlu if CalcDeflection = 1) - Real64 const Pini, // Initial presssure at time of fabrication (used only if CalcDeflection = 1) + Real64 const Pa, // Atmospheric (outside/inside) pressure (used only if CalcDeflection = 1) + Real64 const Pini, // Initial pressure at time of fabrication (used only if CalcDeflection = 1) Real64 const Tini, // Initial temperature at time of fabrication (used only if CalcDeflection = 1) Array1D &gap, // Vector of gap widths [m] Array1D &GapDefMax, // Vector of gap widths in deflected state. It will be used as input @@ -384,7 +384,7 @@ void TARCOG90(EnergyPlusData &state, Array2A const xgvis, // Matrix of constants for gas dynamic viscosity calc Array2A const xgcp, // Matrix of constants for gas specific heat calc at constant pressure const Array1D &xwght, // Vector of Molecular weights for gasses - const Array1D &gama, // Vector of spefic heat ration for low pressure calc + const Array1D &gama, // Vector of specific heat ration for low pressure calc const Array1D_int &nmix, // Vector of number of gasses in gas mixture of each gap const Array1D_int &SupportPillar, // Shows whether or not gap have support pillar const Array1D &PillarSpacing, // Pillar spacing for each gap (used in case there is support pillar) @@ -392,7 +392,7 @@ void TARCOG90(EnergyPlusData &state, Array1D &theta, // Vector of average temperatures of glazing surfaces [K] Array1D &LayerDef, // Vector of layers deflection. [m] Array1D &q, // Vector of various heat fluxes [W/m2] - Array1D &qv, // Vector of heat fluxes to each gap by ventillation [W/m2] + Array1D &qv, // Vector of heat fluxes to each gap by ventilation [W/m2] Real64 &ufactor, // Center of glass U-value [W/m2 K] Real64 &sc, // Shading Coefficient Real64 &hflux, // Net heat flux between room and window [W/m2] @@ -453,7 +453,7 @@ void TARCOG90(EnergyPlusData &state, Array1D &ShadeGapKeffConv, // Vector of convective keff values for areas above/below Real64 const SDScalar, // Factor of Venetian SD layer contribution to convection int const SHGCCalc, // SHGC calculation switch: - int &NumOfIterations, // Number of iterations for reacing solution + int &NumOfIterations, // Number of iterations for reaching solution Real64 const edgeGlCorrFac // Edge of glass correction factor ) { @@ -550,7 +550,7 @@ void TARCOG90(EnergyPlusData &state, // 4 - Xenon // 0 - h to be calculated // 1 - combined film coefficient h prescribed - // 2 - convective film coefficient (hc) prescibed + // 2 - convective film coefficient (hc) prescribed // Also used in old algorithms for calculating h, accessible through negative // values for flags: // -1 - old SPC142 correlation @@ -731,7 +731,7 @@ void TARCOG90(EnergyPlusData &state, SDScalar, ErrorMessage); - // in case of provided deflected gap widths just store deflected widhts before temperatures calculation + // in case of provided deflected gap widths just store deflected widths before temperatures calculation // deflections in this case do not depend of temperatures and it should be calculated before to avoid // one extra call of temperatures calculations if (CalcDeflection == DeflectionCalculation::GAP_WIDTHS) { diff --git a/src/EnergyPlus/TarcogShading.cc b/src/EnergyPlus/TarcogShading.cc index b9350f56fbb..073cd6bc063 100644 --- a/src/EnergyPlus/TarcogShading.cc +++ b/src/EnergyPlus/TarcogShading.cc @@ -130,7 +130,7 @@ namespace TarcogShading { Array1D LayerType, Array1D &Tgaps, Array1D &qv, - Array1D &hcv, // Heat transfer coeefficient in gaps including airlow + Array1D &hcv, // Heat transfer coefficient in gaps including airflow int &nperr, std::string &ErrorMessage, Array1D &vfreevent) @@ -141,7 +141,7 @@ namespace TarcogShading { // gap Vector of gap widths (maxlay) [m] // hgas Convective part of gap effective conductivity // frct Fraction of gasses in a mixture (maxlay1,maxgas) - // iprop Vector of gas identifers (maxlay1,maxgas) + // iprop Vector of gas identifiers (maxlay1,maxgas) // pressure Vector of gas pressures [N/m^2] // nmix Vector of number of gasses for each mixture (maxgas=10) // nlayer Number of glazing layers @@ -160,9 +160,9 @@ namespace TarcogShading { // Input/Output: // Tgaps Vector of gap temperatures [K] // Output: - // qv Vector of heat transfer to the gap by vetilation [W/m^2] + // qv Vector of heat transfer to the gap by ventilation [W/m^2] // hhatv Vector of all film coefficients for vented cavities (maxlay3) - // hcv Vector of surface-to-air heat transfer coefficients by condction/convection for vented cavities [W/(m^2*K)] + // hcv Vector of surface-to-air heat transfer coefficients by conduction/convection for vented cavities [W/(m^2*K)] // Ebgap Vector of emissive power of the vented cavities (maxlay3) // nperr Error flag // vfreevent Vector of free ventilation velocities in gaps @@ -229,7 +229,7 @@ namespace TarcogShading { Ars = Ar(i); Ahs = Ah(i); - // dr.....setting gas properies for two adjacent gaps (or enviroment) + // dr.....setting gas properties for two adjacent gaps (or environment) nmix1 = nmix(i); nmix2 = nmix(i + 1); press1 = pressure(i); @@ -460,7 +460,7 @@ namespace TarcogShading { // exit on error if ((nperr > 0) && (nperr < 1000)) return; - // if (vvent(i).gt.0) then !not implemented for inside shadin yet + // if (vvent(i).gt.0) then !not implemented for inside shading yet // nperr = 1006 // ErrorMessage = 'Forced ventilation not implemented for internal SD layers.' // return @@ -519,7 +519,7 @@ namespace TarcogShading { // Tinlet Temperature of inlet air // Output: // hcv Convective/conductive coefficient for vented gap - // qv Heat transfer to the gap by vetilation [W/m^2] + // qv Heat transfer to the gap by ventilation [W/m^2] // nperr Error flag // ErrorMessage string containing error message //************************************************************************************************************** @@ -972,12 +972,12 @@ namespace TarcogShading { // angle Window angle [degrees] // forcedspeed Speed of forced ventilation [m/s] // hc Convective/conductive coefficient for non-vented gap - // Tenv Enviromental temperature + // Tenv Environmental temperature // Tav Average temperature of gap surfaces // Output: // Tgap Temperature of vented gap // hcv Convective/conductive coefficient for vented gap - // qv Heat transfer to the gap by vetilation [W/m^2] + // qv Heat transfer to the gap by ventilation [W/m^2] // nperr Error flag // speed Air velocity //************************************************************************************************************** @@ -1176,16 +1176,16 @@ namespace TarcogShading { void updateEffectiveMultipliers(int const nlayer, // Number of layers Real64 const width, // IGU width [m] Real64 const height, // IGU height [m] - const Array1D &Atop, // Top openning area [m2] - const Array1D &Abot, // Bottom openning area [m2] - const Array1D &Al, // Left side openning area [m2] - const Array1D &Ar, // Right side openning area [m2] - const Array1D &Ah, // Front side openning area [m2] - Array1D &Atop_eff, // Output - Effective top openning area [m2] - Array1D &Abot_eff, // Output - Effective bottom openning area [m2] - Array1D &Al_eff, // Output - Effective left side openning area [m2] - Array1D &Ar_eff, // Output - Effective right side openning area [m2] - Array1D &Ah_eff, // Output - Effective front side openning area [m2] + const Array1D &Atop, // Top opening area [m2] + const Array1D &Abot, // Bottom opening area [m2] + const Array1D &Al, // Left side opening area [m2] + const Array1D &Ar, // Right side opening area [m2] + const Array1D &Ah, // Front side opening area [m2] + Array1D &Atop_eff, // Output - Effective top opening area [m2] + Array1D &Abot_eff, // Output - Effective bottom opening area [m2] + Array1D &Al_eff, // Output - Effective left side opening area [m2] + Array1D &Ar_eff, // Output - Effective right side opening area [m2] + Array1D &Ah_eff, // Output - Effective front side opening area [m2] const Array1D &LayerType, // Layer type const Array1D &SlatAngle // Venetian layer slat angle [deg] ) diff --git a/src/EnergyPlus/ThermalComfort.cc b/src/EnergyPlus/ThermalComfort.cc index c46a47475ec..f7a7504b969 100644 --- a/src/EnergyPlus/ThermalComfort.cc +++ b/src/EnergyPlus/ThermalComfort.cc @@ -169,7 +169,7 @@ namespace ThermalComfort { CurrentGroupName = state.dataHeatBal->People(Loop).Name; // CurrentModuleObject='People' - // MJW MRT ToDo: Rename most Zone Therml Comfort output varibles to People Thermal Comfort ('cause they're keyed by People name) + // MJW MRT ToDo: Rename most Zone Thermal Comfort output variables to People Thermal Comfort ('cause they're keyed by People name) if (state.dataHeatBal->People(Loop).Fanger) { SetupOutputVariable(state, "Zone Thermal Comfort Fanger Model PMV", @@ -719,7 +719,7 @@ namespace ThermalComfort { P1 = state.dataThermalComforts->CloInsul * state.dataThermalComforts->AbsAirTemp; // p4 P4 = 308.7 - 0.028 * state.dataThermalComforts->IntHeatProd + P2 * pow_4(state.dataThermalComforts->AbsRadTemp / 100.0); // p5 - // First guess for clothed surface tempeature + // First guess for clothed surface temperature state.dataThermalComforts->AbsCloSurfTemp = state.dataThermalComforts->AbsAirTemp + (35.5 - AirTemp) / (3.5 * (CloUnit + 0.1)); XN = state.dataThermalComforts->AbsCloSurfTemp / 100.0; state.dataThermalComforts->HcFor = 12.1 * std::sqrt(AirVel); // Heat transfer coefficient by forced convection @@ -1011,7 +1011,7 @@ namespace ThermalComfort { state.dataThermalComforts->AvgBodyTemp = SkinMassRat * state.dataThermalComforts->SkinTemp + (1.0 - SkinMassRat) * state.dataThermalComforts->CoreTemp; - Real64 SkinThermSigWarm; // vasodialtion signal (WARMS) + Real64 SkinThermSigWarm; // vasodilation signal (WARMS) Real64 SkinThermSigCold; // vasoconstriction signal Real64 SkinSignal = state.dataThermalComforts->SkinTemp - SkinTempSet; // thermoregulatory control signal from the skin if (SkinSignal > 0) { @@ -1693,7 +1693,7 @@ namespace ThermalComfort { Real64 SkinWetSignal; // Skin wettedness signal Real64 SweatCtrlFac; // Sweat control factor Real64 SweatSuppFac; // Sweat suppression factor due to skin wettedness - Real64 WeighFac; // Weighting factor of core siganl + Real64 WeighFac; // Weighting factor of core signal // THE CONTROLLING SYSTEM. // THE CONTROLLING SIGNALS : diff --git a/src/EnergyPlus/ThermalISO15099Calc.cc b/src/EnergyPlus/ThermalISO15099Calc.cc index 2318fc0eaee..63a0fb6c454 100644 --- a/src/EnergyPlus/ThermalISO15099Calc.cc +++ b/src/EnergyPlus/ThermalISO15099Calc.cc @@ -79,7 +79,7 @@ namespace EnergyPlus::ThermalISO15099Calc { // RE-ENGINEERED March/27/2012, Simon Vidanovic // Revision: 7.0.13 (March/27/2012), Simon Vidanovic -// - feature: New set of equaitons is set instead of hhat coefficents and new approach to solution which improves +// - feature: New set of equations is set instead of hhat coefficients and new approach to solution which improves // speed and stability. Note that this solution does not include laminates // PURPOSE OF THIS MODULE: @@ -1309,7 +1309,7 @@ void therm1d(EnergyPlusData &state, // b Array // hhat Vector // err iteration tolerance - // dtmax max temp dfference after iteration + // dtmax max temp difference after iteration // index iteration step // Using @@ -1339,7 +1339,7 @@ void therm1d(EnergyPlusData &state, Array1D x({1, 4 * nlayer}); // temporary vector for storing results (theta and Radiation). used for easier handling Array1D dX({1, 4 * nlayer}, 0.0); // difference in results - Array2D Jacobian({1, 4 * nlayer}, {1, 4 * nlayer}); // diagonal vector for jacobian comuptation-free newton method + Array2D Jacobian({1, 4 * nlayer}, {1, 4 * nlayer}); // diagonal vector for jacobian computation-free newton method Array1D DRes({1, 4 * nlayer}); // used in jacobian forward-difference approximation // This is used to store matrix before equation solver. It is important because solver destroys @@ -1800,7 +1800,7 @@ void therm1d(EnergyPlusData &state, } // f (currentTry == NumOfTries) then } - // Chek if results were found: + // Check if results were found: if (curDifference < ConvergenceTolerance) { CalcOutcome = CalculationOutcome::OK; TotalIndex += index; @@ -2063,7 +2063,7 @@ void solarISO15099(Real64 const totsol, Real64 const rtot, const Array1D // This subroutine calculates the shading coefficient for a window. //*********************************************************************** // Inputs: - // absol array of absorped fraction of solar radiation in lites + // absol array of absorbed fraction of solar radiation in lites // totsol total solar transmittance // rtot total thermal resistance of window // rs array of thermal resistances of each gap and layer @@ -2409,8 +2409,8 @@ void effectiveLayerCond(EnergyPlusData &state, Array2A const gcon, // Gas specific conductivity Array2A const gvis, // Gas specific viscosity Array2A const gcp, // Gas specific heat - const Array1D &EffectiveOpenness, // Layer effective openneess [m2] - Array1D &theta, // Layer surface tempeartures [K] + const Array1D &EffectiveOpenness, // Layer effective openness [m2] + Array1D &theta, // Layer surface temperatures [K] Array1D &sconScaled, // Layer conductivity divided by thickness int &nperr, // Error message flag std::string &ErrorMessage // Error message @@ -2492,9 +2492,9 @@ void filmi(EnergyPlusData &state, // presure // nmix vector of number of gasses in a mixture for each gap // Output - // hcin - indoor convecive heat transfer coeff + // hcin - indoor convective heat transfer coeff - // If there is forced air in the room than use SPC142 corelation 5.49 to calculate the room side film coefficient. + // If there is forced air in the room than use SPC142 correlation 5.49 to calculate the room side film coefficient. // Using // Argument array dimensioning @@ -2623,7 +2623,7 @@ void filmg(EnergyPlusData &state, std::string &ErrorMessage) { //*********************************************************************** - // sobroutine to calculate effective conductance of gaps + // subroutine to calculate effective conductance of gaps //*********************************************************************** // Inputs: // tilt window angle (deg) @@ -2786,7 +2786,7 @@ void filmPillar(EnergyPlusData &state, (pow_2(PillarSpacing(state.dataThermalISO15099Calc->iFP)) * (1.0 + 2.0 * gap(state.dataThermalISO15099Calc->iFP) / (Constant::Pi * PillarRadius(state.dataThermalISO15099Calc->iFP)))); - // It is important to add on prevoius values caluculated for gas + // It is important to add on previous values calculated for gas hcgas(state.dataThermalISO15099Calc->iFP + 1) += state.dataThermalISO15099Calc->cpa; } // if (SupportPillar(i).eq.YES_SupportPillar) then } diff --git a/src/EnergyPlus/TranspiredCollector.cc b/src/EnergyPlus/TranspiredCollector.cc index aacbbd87e55..62d81ea1736 100644 --- a/src/EnergyPlus/TranspiredCollector.cc +++ b/src/EnergyPlus/TranspiredCollector.cc @@ -92,7 +92,7 @@ namespace TranspiredCollector { // RE-ENGINEERED na // PURPOSE OF THIS MODULE: - // Ecapsulates data and routines for simulating unglazed transpired solar collectors (UTSC) + // Encapsulates data and routines for simulating unglazed transpired solar collectors (UTSC) // as a component on the HVAC air system. // METHODOLOGY EMPLOYED: @@ -249,9 +249,9 @@ namespace TranspiredCollector { Array1D Numbers(11); // Numeric items for object int NumAlphas; // Number of Alphas for each GetObjectItem call int NumNumbers; // Number of Numbers for each GetObjectItem call - int MaxNumAlphas; // argumenet for call to GetObjectDefMaxArgs - int MaxNumNumbers; // argumenet for call to GetObjectDefMaxArgs - int Dummy; // argumenet for call to GetObjectDefMaxArgs + int MaxNumAlphas; // argument for call to GetObjectDefMaxArgs + int MaxNumNumbers; // argument for call to GetObjectDefMaxArgs + int Dummy; // argument for call to GetObjectDefMaxArgs int IOStatus; // Used in GetObjectItem bool ErrorsFound(false); // Set to true if errors in input, fatal at end of routine int Found; @@ -270,8 +270,8 @@ namespace TranspiredCollector { Array1D NumbersSplit(1); // Numeric items for object int NumAlphasSplit; // Number of Alphas for each GetObjectItem call int NumNumbersSplit; // Number of Numbers for each GetObjectItem call - int MaxNumAlphasSplit; // argumenet for call to GetObjectDefMaxArgs - int MaxNumNumbersSplit; // argumenet for call to GetObjectDefMaxArgs + int MaxNumAlphasSplit; // argument for call to GetObjectDefMaxArgs + int MaxNumNumbersSplit; // argument for call to GetObjectDefMaxArgs int IOStatusSplit; // Used in GetObjectItem int NumOASys; // do loop counter int ACountBase; // counter for alhpasSplit @@ -634,7 +634,7 @@ namespace TranspiredCollector { if (ErrorsFound) continue; // previous inner do loop may have detected problems that need to be cycle'd again to avoid crash - // now that we should have all the surfaces, do some preperations and checks. + // now that we should have all the surfaces, do some preparations and checks. // are they all similar tilt and azimuth? Issue warnings so people can do it if they really want Real64 const surfaceArea(sum_sub(state.dataSurface->Surface, &SurfaceData::Area, state.dataTranspiredCollector->UTSC(Item).SurfPtrs)); @@ -982,7 +982,7 @@ namespace TranspiredCollector { sum_sub(state.dataLoopNodes->Node, &DataLoopNode::NodeData::MassFlowRate, state.dataTranspiredCollector->UTSC(UTSCNum).InletNode); // Autodesk:F2C++ Functions handle array subscript usage - state.dataTranspiredCollector->UTSC(UTSCNum).IsOn = false; // intialize then turn on if appropriate + state.dataTranspiredCollector->UTSC(UTSCNum).IsOn = false; // initialize then turn on if appropriate state.dataTranspiredCollector->UTSC(UTSCNum).Tplen = state.dataTranspiredCollector->UTSC(UTSCNum).TplenLast; state.dataTranspiredCollector->UTSC(UTSCNum).Tcoll = state.dataTranspiredCollector->UTSC(UTSCNum).TcollLast; state.dataTranspiredCollector->UTSC(UTSCNum).TairHX = Tamb; @@ -1038,7 +1038,7 @@ namespace TranspiredCollector { Real64 HcPlen; // surface convection heat transfer coefficient for plenum surfaces Real64 D; // hole diameter Real64 ReD; // Reynolds number for holes - Real64 P; // pitch, distance betweeen holes + Real64 P; // pitch, distance between holes Real64 Por; // porosity, area fraction of collector that is open because of holes Real64 Mdot; // mass flow rate of suction air Real64 QdotSource; // energy flux for source/sink inside collector surface (for hybrid PV UTSC) @@ -1046,13 +1046,13 @@ namespace TranspiredCollector { int NumSurfs; // number of underlying HT surfaces associated with UTSC Material::SurfaceRoughness Roughness; // parameters for surface roughness, defined in DataHeatBalance Real64 SolAbs; // solar absorptivity of collector - Real64 AbsExt; // thermal emmittance of collector + Real64 AbsExt; // thermal emittance of collector Real64 TempExt; // collector temperature int SurfPtr; // index of surface in main surface structure Real64 HMovInsul; // dummy for call to InitExteriorConvectionCoeff Real64 HExt; // dummy for call to InitExteriorConvectionCoeff int ConstrNum; // index of construction in main construction structure - Real64 AbsThermSurf; // thermal emmittance of underlying wall. + Real64 AbsThermSurf; // thermal emittance of underlying wall. Real64 TsoK; // underlying surface temperature in Kelvin Real64 TscollK; // collector temperature in Kelvin (lagged) Real64 AreaSum; // sum of contributing surfaces for area-weighted averages. diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 9da1b5a1573..32020803ff2 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -2621,7 +2621,7 @@ namespace UnitarySystems { // mine capacity from Coil:Cooling:DX object auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; - // TODO: Determine operating mode based on dehumdification stuff, using normalMode for now + // TODO: Determine operating mode based on dehumidification stuff, using normalMode for now if (this->m_NumOfSpeedCooling != (int)newCoil.performance.normalMode.speeds.size()) { ShowWarningError(state, format("{}: {} = {}", RoutineName, CompType, CompName)); ShowContinueError(state, "Number of cooling speeds does not match coil object."); @@ -6946,7 +6946,7 @@ namespace UnitarySystems { std::string const &thisObjectName = Util::makeUPPER(instance.key()); // only get the current data once all data has been read in and vector unitarySys has been initialized - // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the curren object + // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue; int sysNum = getUnitarySystemIndex(state, thisObjectName); @@ -7072,7 +7072,7 @@ namespace UnitarySystems { std::string const &thisObjectName = Util::makeUPPER(instance.key()); // only get the current data once all data has been read in and vector unitarySys has been initialized - // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the curren object + // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue; int sysNum = getUnitarySystemIndex(state, thisObjectName); @@ -7387,7 +7387,7 @@ namespace UnitarySystems { std::string const &thisObjectName = Util::makeUPPER(instance.key()); // only get the current data once all data has been read in and vector unitarySys has been initialized - // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the curren object + // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue; int sysNum = getUnitarySystemIndex(state, thisObjectName); @@ -7676,7 +7676,7 @@ namespace UnitarySystems { Real64 const OAUCoilOutTemp, // the coil inlet temperature of OutdoorAirUnit bool HXUnitOn, // Flag to control HX for HXAssisted Cooling Coil Real64 &sysOutputProvided, // system sensible output at supply air node - Real64 &latOutputProvided // sytsem latent output at supply air node + Real64 &latOutputProvided // system latent output at supply air node ) { @@ -8118,7 +8118,7 @@ namespace UnitarySystems { if (this->m_EMSOverrideSensZoneLoadRequest) ZoneLoad = this->m_EMSSensibleZoneLoadValue; if (this->m_EMSOverrideMoistZoneLoadRequest) state.dataUnitarySystems->MoistureLoad = this->m_EMSMoistureZoneLoadValue; - this->m_SimASHRAEModel = false; // flag used to envoke ASHRAE 90.1 model calculations + this->m_SimASHRAEModel = false; // flag used to invoke ASHRAE 90.1 model calculations // allows non-ASHSRAE compliant coil types to be modeled using non-ASHAR90 method. Constant fan operating mode is required. if (this->m_FanOpMode == HVAC::FanOp::Continuous) { if (state.dataUnitarySystems->CoolingLoad) { @@ -10140,7 +10140,7 @@ namespace UnitarySystems { this->m_LatLoadLoss = 0.0; } - // Calcuate air distribution losses + // Calculate air distribution losses if (!FirstHVACIteration && state.afn->AirflowNetworkFanActivated) { Real64 DeltaMassRate = 0.0; Real64 TotalOutput = 0.0; // total output rate, {W} @@ -10426,10 +10426,10 @@ namespace UnitarySystems { } if (!this->m_RunOnLatentLoad) state.dataUnitarySystems->MoistureLoad = 0.0; - // Testing heat pump air to air with RH control with CoolReheat dehumidifaction control showed that when there was heating + // Testing heat pump air to air with RH control with CoolReheat dehumidification control showed that when there was heating // and moisture load, the cooling coil was turning on to meet the moisture load and reheat was then turning on to meet both // heating load and excess cooling load caused by cooling coil. Adding the logic below caused the zone temperature, - // relative humidity, cooling/heating rate to line up for both the orignal and new file with unitary system object. + // relative humidity, cooling/heating rate to line up for both the original and new file with unitary system object. if (this->m_SuppCoilExists) { if (this->m_DehumidControlType_Num == DehumCtrlType::CoolReheat) { @@ -10551,7 +10551,7 @@ namespace UnitarySystems { if (this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP || this->m_sysType == SysType::PackagedWSHP) { state.dataUnitarySystems->OACompOnMassFlow = this->m_HeatOutAirMassFlow; - // does this assume OA flow <= min speed flow? wihtout this there are SolveRoot failures. + // does this assume OA flow <= min speed flow? without this there are SolveRoot failures. if (HeatSpeedNum > 1) { state.dataUnitarySystems->OACompOffMassFlow = this->m_HeatOutAirMassFlow; } @@ -11049,7 +11049,7 @@ namespace UnitarySystems { } // BEGIN - refactor/move this to Init during FirstHVACIteration, need struct or module level global for turnFansOn and turnFansOff - // If the unitary system is scheduled on or nightime cycle overrides fan schedule. Uses same logic as fan. + // If the unitary system is scheduled on or nighttime cycle overrides fan schedule. Uses same logic as fan. FanOn = (this->m_FanExists) ? ScheduleManager::GetCurrentScheduleValue(state, this->m_FanAvailSchedPtr) > 0 : true; // END - move this to Init during FirstHVACIteration @@ -12264,7 +12264,7 @@ namespace UnitarySystems { // Multimode coil will switch to enhanced dehumidification IF available and needed, but it // still runs to meet the sensible load. Multimode applies to Multimode or HXAssistedCooling coils. if ((SensibleLoad && this->m_RunOnSensibleLoad) || (LatentLoad && this->m_RunOnLatentLoad)) { - // calculate sensible PLR, don't care IF latent is true here but need to gaurd for + // calculate sensible PLR, don't care IF latent is true here but need to guard for // when LatentLoad=TRUE and SensibleLoad=FALSE ReqOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate * Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(DesOutTemp, diff --git a/src/EnergyPlus/VariableSpeedCoils.cc b/src/EnergyPlus/VariableSpeedCoils.cc index 324a94c8872..fb069db95c6 100644 --- a/src/EnergyPlus/VariableSpeedCoils.cc +++ b/src/EnergyPlus/VariableSpeedCoils.cc @@ -845,7 +845,7 @@ namespace VariableSpeedCoils { OutputProcessor::Group::HVAC, OutputProcessor::EndUseCat::CoolingCoils); - // for table output, being consistent with outher water-to-air coils + // for table output, being consistent with other water-to-air coils // IF (VarSpeedCoil(DXCoilNum)%RatedCapCoolTotal /= AutoSize) THEN // VarSpeedCoil(DXCoilNum)%RatedCapCoolSens = VarSpeedCoil(DXCoilNum)%RatedCapCoolTotal & // *VarSpeedCoil(DXCoilNum)%MSRatedSHR(VarSpeedCoil(DXCoilNum)%NormSpedLevel) @@ -4041,7 +4041,7 @@ namespace VariableSpeedCoils { // VarSpeedCoil(DXCoilNum)%MSRatedAirMassFlowRate(Mode), & // VarSpeedCoil(DXCoilNum)%MSRatedSHR(Mode)) } - // call coil model with everthing set at rating point + // call coil model with everything set at rating point state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTemp; state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTemp, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel); diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc index 959fb06816f..4af27cd3f6f 100644 --- a/src/EnergyPlus/WaterCoils.cc +++ b/src/EnergyPlus/WaterCoils.cc @@ -1186,7 +1186,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA // the cooling coil. // Basic Idea for UA: Heat Transfer= UAenthalpybased*(Delta enthalpy), this is a necessity since the // coil may be Wet or Dry or Partially Wet-Dry, so latent effects are accounted for in this model while - // calculating the UA. A fictitious specific heat is also defined to caculate the conventional UA. + // calculating the UA. A fictitious specific heat is also defined to calculate the conventional UA. // On the air side, enthalpy capacity rate is the air mass flow rate,while on water side it is // enthalpy of saturated air at water temperature. //@@@ DESIGN CONDITION BEGIN HERE @@@ @@ -1295,7 +1295,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA // Total Coil Load from Inlet and Outlet Air States (which include fan heat as appropriate). waterCoil.DesTotWaterCoilLoad = waterCoil.DesAirMassFlowRate * (DesInletAirEnth - DesOutletAirEnth); - // Enthalpy of Water at Intlet design conditions + // Enthalpy of Water at Inlet design conditions Cp = GetSpecificHeatGlycol(state, state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).FluidName, waterCoil.DesInletWaterTemp, @@ -1453,7 +1453,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA // Now use SolveRoot to "invert" the cooling coil model to obtain the UA given the specified design inlet and outlet conditions // Note that the UAs we have obtained so far are rough estimates that are the starting points for the the following iterative - // calulation of the actual UAs. + // calculation of the actual UAs. waterCoil.InletAirTemp = waterCoil.DesInletAirTemp; waterCoil.InletAirHumRat = waterCoil.DesInletAirHumRat; waterCoil.InletWaterTemp = waterCoil.DesInletWaterTemp; @@ -1729,7 +1729,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA if (waterCoil.DesWaterCoolingCoilRate <= 0.0) waterCoil.DesWaterCoolingCoilRate = waterCoil.TotWaterCoolingCoilRate; if (waterCoil.DesWaterHeatingCoilRate <= 0.0) waterCoil.DesWaterHeatingCoilRate = waterCoil.TotWaterHeatingCoilRate; - // call coil model with everthing set at rating point + // call coil model with everything set at rating point waterCoil.InletAirMassFlowRate = waterCoil.DesAirMassFlowRate; waterCoil.InletAirTemp = waterCoil.DesInletAirTemp; waterCoil.InletAirHumRat = waterCoil.DesInletAirHumRat; // fixed in sizing routine diff --git a/src/EnergyPlus/WindTurbine.cc b/src/EnergyPlus/WindTurbine.cc index ab1ee89df7d..da1c6bc1909 100644 --- a/src/EnergyPlus/WindTurbine.cc +++ b/src/EnergyPlus/WindTurbine.cc @@ -183,7 +183,7 @@ namespace WindTurbine { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // This subroutine provides a "get" method to collect results for individual electic load centers. + // This subroutine provides a "get" method to collect results for individual electric load centers. GeneratorPower = state.dataWindTurbine->WindTurbineSys(GeneratorIndex).Power; GeneratorEnergy = state.dataWindTurbine->WindTurbineSys(GeneratorIndex).Energy; @@ -897,7 +897,7 @@ namespace WindTurbine { // SUBROUTINE INFORMATION: // AUTHOR Daeho Kang - // DATE WRITTEN Octorber 2009 + // DATE WRITTEN October 2009 // MODIFIED na // RE-ENGINEERED na @@ -942,7 +942,7 @@ namespace WindTurbine { Real64 IntRelFlowVel; // Integration of relative flow velocity Real64 TotTorque; // Total torque for the number of blades Real64 Omega; // Angular velocity of rotor in rad/s - Real64 TanForceCoeff; // Tnagential force coefficient + Real64 TanForceCoeff; // Tangential force coefficient Real64 NorForceCoeff; // Normal force coefficient Real64 Period; // Period of sine and cosine functions Real64 C1; // Empirical power coefficient C1 diff --git a/src/EnergyPlus/WindowEquivalentLayer.cc b/src/EnergyPlus/WindowEquivalentLayer.cc index 91d406d50e7..673377c54fa 100644 --- a/src/EnergyPlus/WindowEquivalentLayer.cc +++ b/src/EnergyPlus/WindowEquivalentLayer.cc @@ -171,7 +171,7 @@ void SetEquivalentLayerWindowProperties(EnergyPlusData &state, int const ConstrN // PURPOSE OF THIS SUBROUTINE: // Populates the the equivalent layer window model optical and thermal - // properties, fills default values and shades geomterical calculations + // properties, fills default values and shades geometrical calculations // METHODOLOGY EMPLOYED: // uses some routine developed for ASHRAE RP-1311 (ASHWAT Model) @@ -420,7 +420,7 @@ void CalcEQLWindowUvalue(EnergyPlusData &state, static constexpr std::string_view RoutineName("CalcEQLWindowUvalue: "); Real64 U; // U-factor, W/m2-K - Real64 UOld; // U-factor during pevious iteration step, W/m2-K + Real64 UOld; // U-factor during previous iteration step, W/m2-K Real64 HXO; // outdoor combined conv+rad surf coeff, W/m2-K Real64 HXI; // indoor combined conf+rad surf coeff, W/m2-K Real64 HRO; // outdoor side radiation surf coeff, W/m2-K @@ -438,7 +438,7 @@ void CalcEQLWindowUvalue(EnergyPlusData &state, bool CFSURated = false; // false if U-Value calculation failed - // Intial guess value for combined conductance + // Initial guess value for combined conductance HXO = 29.0; // 1/FenROut HXI = 7.0; // 1/FenRIn HCO = 26.0; @@ -457,7 +457,7 @@ void CalcEQLWindowUvalue(EnergyPlusData &state, ((TGO + Constant::Kelvin) + (TOUT + Constant::Kelvin)); HRI = Constant::StefanBoltzmann * EI * (pow_2(TGI + Constant::Kelvin) + pow_2(TIN + Constant::Kelvin)) * ((TGI + Constant::Kelvin) + (TIN + Constant::Kelvin)); - // HCI = HIC_ASHRAE( Height, TGI, TI) ! BAN June 2103 Raplaced with ISO Std 15099 + // HCI = HIC_ASHRAE( Height, TGI, TI) ! BAN June 2103 Replaced with ISO Std 15099 TGIK = TGI + Constant::Kelvin; TIK = TIN + Constant::Kelvin; HCI = HCInWindowStandardRatings(state, Height, TGIK, TIK); @@ -495,7 +495,7 @@ void CalcEQLWindowSHGCAndTransNormal(EnergyPlusData &state, // METHODOLOGY EMPLOYED: // Uses routine developed for ASHRAE RP-1311 (ASHWAT Model) - // Summer Window Rating Conditoions + // Summer Window Rating Conditions // tin = 297.15d0 ! indoor air condition (75.2F, 24.0C) // tout = 305.15d0 ! Outside air temperature (89.6F, 32C) // hcout = 15.d0 ! Outside convective film conductance at 2.8 m/s (6.2 mph) wind speed @@ -655,11 +655,11 @@ void CalcEQLWindowOpticalProperty(EnergyPlusData &state, void EQLWindowSurfaceHeatBalance(EnergyPlusData &state, int const SurfNum, // Surface number - Real64 const HcOut, // outside convection coeficient at this timestep, W/m2K + Real64 const HcOut, // outside convection coefficient at this timestep, W/m2K Real64 &SurfInsideTemp, // Inside window surface temperature (innermost face) [C] Real64 &SurfOutsideTemp, // Outside surface temperature (C) Real64 &SurfOutsideEmiss, - DataBSDFWindow::Condition const CalcCondition // Calucation condition (summer, winter or no condition) + DataBSDFWindow::Condition const CalcCondition // Calculation condition (summer, winter or no condition) ) { // SUBROUTINE INFORMATION: @@ -704,7 +704,7 @@ void EQLWindowSurfaceHeatBalance(EnergyPlusData &state, Real64 QXConv; // extra convective gain from this surface Real64 TaIn(0); // zone air temperature Real64 tsky; // sky temperature - Real64 HcIn; // inside convection coeficient at this timestep, W/m2K + Real64 HcIn; // inside convection coefficient at this timestep, W/m2K Real64 ConvHeatFlowNatural; // Convective heat flow from gap between glass and interior shade or blind (W) Real64 NetIRHeatGainWindow; // net radiation gain from the window surface to the zone (W) Real64 ConvHeatGainWindow; // net convection heat gain from inside surface of window to zone air (W) @@ -836,7 +836,7 @@ void EQLWindowSurfaceHeatBalance(EnergyPlusData &state, state.dataSurface->SurfWinGainIRGlazToZoneRep(SurfNum) = NetIRHeatGainWindow; state.dataSurface->SurfWinGainIRShadeToZoneRep(SurfNum) = NetIRHeatGainWindow; if (InSideLayerType == LayerType::GLAZE) { - // no interior sade + // no interior shade state.dataSurface->SurfWinGainIRShadeToZoneRep(SurfNum) = 0.0; } else { // Interior shade exists @@ -862,12 +862,12 @@ void OPENNESS_LW(Real64 const OPENNESS, // shade openness (=tausbb at normal inc // (= wire or thread emittance) // typical (default) values // dark insect screen = .93 - // metalic insect screen = .32 + // metallic insect screen = .32 // roller blinds = .91 // drape fabric = .87 // typical (default) values // dark insect screen = .02 - // metalic insect screen = .19 + // metallic insect screen = .19 // roller blinds = .05 // drape fabric = .05 @@ -911,7 +911,7 @@ HEMINT(EnergyPlusData &state, // AUTHOR ASHRAE 1311-RP // PURPOSE OF THIS FUNCTION: - // Romberg Integration of Property function over hemispeherical dome + // Romberg Integration of Property function over hemispherical dome // METHODOLOGY EMPLOYED: // Romberg Integration. @@ -1003,8 +1003,8 @@ void RB_DIFF(EnergyPlusData &state, SumRefAndTran = RHO_DD + TAU_DD; ShowWarningMessage(state, format("{}Roller blind diffuse-diffuse properties are inconsistent", RoutineName)); ShowContinueError(state, format("...The diffuse-diffuse reflectance = {:.4T}", RHO_DD)); - ShowContinueError(state, format("...The diffuse-diffuse tansmittance = {:.4T}", TAU_DD)); - ShowContinueError(state, format("...Sum of diffuse reflectance and tansmittance = {:.4T}", SumRefAndTran)); + ShowContinueError(state, format("...The diffuse-diffuse transmittance = {:.4T}", TAU_DD)); + ShowContinueError(state, format("...Sum of diffuse reflectance and transmittance = {:.4T}", SumRefAndTran)); ShowContinueError(state, "...This sum cannot be > 1.0. Transmittance will be reset to 1 minus reflectance"); TAU_DD = 1.0 - RHO_DD; } @@ -1137,8 +1137,8 @@ void IS_DIFF(EnergyPlusData &state, SumRefAndTran = RHO_DD + TAU_DD; ShowWarningMessage(state, format("{}Calculated insect screen diffuse-diffuse properties are inconsistent", RoutineName)); ShowContinueError(state, format("...The diffuse-diffuse reflectance = {:.4T}", RHO_DD)); - ShowContinueError(state, format("...The diffuse-diffuse tansmittance = {:.4T}", TAU_DD)); - ShowContinueError(state, format("...Sum of diffuse reflectance and tansmittance = {:.4T}", SumRefAndTran)); + ShowContinueError(state, format("...The diffuse-diffuse transmittance = {:.4T}", TAU_DD)); + ShowContinueError(state, format("...Sum of diffuse reflectance and transmittance = {:.4T}", SumRefAndTran)); ShowContinueError(state, "...This sum cannot be > 1.0. Transmittance will be reset to 1 minus reflectance"); TAU_DD = 1.0 - RHO_DD; } @@ -1310,8 +1310,8 @@ void FM_DIFF(EnergyPlusData &state, SumRefAndTran = RHO_DD + TAU_DD; ShowWarningMessage(state, format("{}Calculated drape fabric diffuse-diffuse properties are inconsistent", RoutineName)); ShowContinueError(state, format("...The diffuse-diffuse reflectance = {:.4T}", RHO_DD)); - ShowContinueError(state, format("...The diffuse-diffuse tansmittance = {:.4T}", TAU_DD)); - ShowContinueError(state, format("...Sum of diffuse reflectance and tansmittance = {:.4T}", SumRefAndTran)); + ShowContinueError(state, format("...The diffuse-diffuse transmittance = {:.4T}", TAU_DD)); + ShowContinueError(state, format("...Sum of diffuse reflectance and transmittance = {:.4T}", SumRefAndTran)); ShowContinueError(state, "...This sum cannot be > 1.0. Transmittance will be reset to 1 minus reflectance"); TAU_DD = 1.0 - RHO_DD; } @@ -1370,7 +1370,7 @@ void FM_BEAM(EnergyPlusData &state, // PURPOSE OF THIS SUBROUTINE: // Calculates the solar optical properties of a fabric for beam radiation incident - // on the forward facingsurface using optical properties at normal incidence and + // on the forward facing surface using optical properties at normal incidence and // semi-empirical relations. // SUBROUTINE ARGUMENT DEFINITIONS: @@ -3386,7 +3386,7 @@ void PD_BEAM_CASE_VI(Real64 const S, // pleat spacing (> Real64 AK; // length of diagonal strings Real64 CG; - Real64 Z1_BD; // diffuse source termps + Real64 Z1_BD; // diffuse source terms Real64 Z7_BD; // shape factors Real64 F12; @@ -3518,7 +3518,7 @@ void VB_DIFF(EnergyPlusData &state, Real64 const PHI, // slat angle, radians (-PI/2 <= PHI <= PI/2) Real64 const RHODFS_SLAT, // reflectance of downward-facing slat surfaces (concave?) Real64 const RHOUFS_SLAT, // reflectance of upward-facing slat surfaces (convex?) - Real64 const TAU_SLAT, // diffuse transmitance of slats + Real64 const TAU_SLAT, // diffuse transmittance of slats Real64 &RHOFVB, // returned: front side effective diffuse reflectance of venetian blind Real64 &TAUVB // returned: effective diffuse transmittance of venetian blind ) @@ -4283,8 +4283,8 @@ void ASHWAT_ThermalCalc(EnergyPlusData &state, Array1D HJC(FS.NL); Array1D RHOF({0, FS.NL + 1}); // longwave reflectance, front ! these variables help simplify Array1D RHOB({0, FS.NL + 1}); // longwave reflectance, back ! the code because it is useful to - Array1D EPSF({0, FS.NL + 1}); // longwave emisivity, front ! increase the scope of the arrays - Array1D EPSB({0, FS.NL + 1}); // longwave emisivity, back ! to include indoor and outdoor + Array1D EPSF({0, FS.NL + 1}); // longwave emissivity, front ! increase the scope of the arrays + Array1D EPSB({0, FS.NL + 1}); // longwave emissivity, back ! to include indoor and outdoor Array1D TAU({0, FS.NL + 1}); // longwave transmittance ! nodes - more general Array2D HC2D(6, 6); // convective heat transfer coefficients between layers i and j Array2D HR2D(6, 6); // radiant heat transfer coefficients between layers i and j @@ -4745,8 +4745,8 @@ bool ASHWAT_ThermalRatings(EnergyPlusData &state, Real64 Q_IN; // net gain to the room [W/m2], including transmitted solar Array1D RHOF({0, FS.NL + 1}); // longwave reflectance, front ! these variables help simplify Array1D RHOB({0, FS.NL + 1}); // longwave reflectance, back ! the code because it is useful to - Array1D EPSF({0, FS.NL + 1}); // longwave emisivity, front ! increase the scope of the arrays - Array1D EPSB({0, FS.NL + 1}); // longwave emisivity, back ! to include indoor and outdoor + Array1D EPSF({0, FS.NL + 1}); // longwave emissivity, front ! increase the scope of the arrays + Array1D EPSB({0, FS.NL + 1}); // longwave emissivity, back ! to include indoor and outdoor Array1D TAU({0, FS.NL + 1}); // longwave transmittance ! nodes - more general Real64 RTOT; // total resistance from TAE_OUT to TAE_IN [m2K/W] Array2D HC2D(6, 6); // convective heat transfer coefficients between layers i and j @@ -5162,7 +5162,7 @@ bool ASHWAT_ThermalRatings(EnergyPlusData &state, // CHANGE TO (NDLIAR .GT. 2) ONCE // SUBROUTINE DL2_RES IS AVAILABLE - // calculate radiant heat transfer coefficents between adjacent opaque + // calculate radiant heat transfer coefficients between adjacent opaque // layers for (I = 0; I <= NL; ++I) { // scan through all gaps - including indoor/outdoor if ((ISDL(I) == 0) && (ISDL(I + 1) == 0)) { @@ -5176,7 +5176,7 @@ bool ASHWAT_ThermalRatings(EnergyPlusData &state, } } // end loop through gaps - // calculate radiant heat transfer coefficents at single diathermanous + // calculate radiant heat transfer coefficients at single diathermanous // layers,three coefficients in each case for (I = 0; I <= NL - 1; ++I) { // scan through all layers - look for single DL @@ -5198,7 +5198,7 @@ bool ASHWAT_ThermalRatings(EnergyPlusData &state, } // end of IF(ISDL(I) .EQ. 0) .AND. ..... } // end of scan through all layers - // calculate radiant heat transfer coefficents at double diathermanous + // calculate radiant heat transfer coefficients at double diathermanous // layers,six coefficients in each case // THIS SECTION NOT ACTIVE YET @@ -5545,7 +5545,7 @@ bool ASHWAT_ThermalRatings(EnergyPlusData &state, Q_IN = UCG * (TAE_OUT - TAE_IN) + SHGC * ISOL; // End of new code - for calculating Ucg and SHGC - // restore convective heat transfer coefficients if alterred earlier + // restore convective heat transfer coefficients if altered earlier // for more general resistor network - otherwise mainline will // receive faulty data if (NL >= 2) { // no OCF unless at least two layers exist @@ -5579,9 +5579,9 @@ void DL_RES_r2(Real64 const Tg, // mean glass layer temperature, {K} // Returns the radiant heat transfer coefficients between parallel surfaces: // METHODOLOGY EMPLOYED: // Solves radiant heat transfer coefficients between three parallel surfaces. - // The left and right surfcaes are opaque with reflectance rhog and rhom, respectively. + // The left and right surfaces are opaque with reflectance rhog and rhom, respectively. // And the middle layer is diathermanous with transmittance taud AND reflectance rhodf - // and rhodb on the left and rightsides, respectively. + // and rhodb on the left and right sides, respectively. // The subscripts g, d and m apply to Glass, Diathermanous layer, and mean-radiant room // temperature in a configuration of a window with an indoor-side shading attachment // but the analysis can be applied to any three layers in the configuration described @@ -5885,7 +5885,7 @@ void SLtoGL(EnergyPlusData const &state, // properties of AIR rho = state.dataWindowEquivalentLayer->PAtmSeaLevel / (287.097 * Tavg); // density (kg/m3) <- temperature in (K) - beta = 1.0 / Tavg; // thermal expansion coef(/K) + beta = 1.0 / Tavg; // thermal expansion coeff (/K) dvisc = (18.05 + ((Tavg - 290.0) / 10.0) * (18.53 - 18.05)) * 1.0e-6; // dynamic viscosity (kg/m.sec) or (N.sec/m2) Cp = 1044.66 - 0.31597 * Tavg + 0.000707908 * pow_2(Tavg) - 0.00000027034 * pow_3(Tavg); @@ -5943,7 +5943,7 @@ Real64 SLtoAMB(EnergyPlusData const &state, // properties of AIR Tavg = (Ts + Tamb) / 2.0; rho = state.dataWindowEquivalentLayer->PAtmSeaLevel / (287.097 * Tavg); // density (kg/m3) <- temperature in (K) - beta = 1.0 / Tavg; // thermal expansion coef(/K) + beta = 1.0 / Tavg; // thermal expansion coeff (/K) dvisc = (18.05 + ((Tavg - 290.0) / 10.0) * (18.53 - 18.05)) * 1.0e-6; // dynamic viscosity (kg/m.sec) or (N.sec/m2) Cp = 1044.66 - 0.31597 * Tavg + 0.000707908 * pow_2(Tavg) - 0.00000027034 * pow_3(Tavg); @@ -5972,7 +5972,7 @@ Real64 SLtoAMB(EnergyPlusData const &state, // properties of AIR Tavg = (Ts + Tamb) / 2.0; rho = state.dataWindowEquivalentLayer->PAtmSeaLevel / (287.097 * Tavg); // density (kg/m3) <- temperature in (K) - beta = 1.0 / Tavg; // thermal expansion coef(/K) + beta = 1.0 / Tavg; // thermal expansion coeff (/K) dvisc = (18.05 + ((Tavg - 290.0) / 10.0) * (18.53 - 18.05)) * 1.0e-6; // dynamic viscosity (kg/m.sec) or (N.sec/m2) Cp = 1044.66 - 0.31597 * Tavg + 0.000707908 * pow_2(Tavg) - 0.00000027034 * pow_3(Tavg); @@ -6047,7 +6047,7 @@ void GLtoAMB(EnergyPlusData const &state, // properties of AIR rho = state.dataWindowEquivalentLayer->PAtmSeaLevel / (287.097 * Tavg); // density (kg/m3) <- temperature in (K) - beta = 1.0 / Tavg; // thermal expansion coef(/K) + beta = 1.0 / Tavg; // thermal expansion coeff (/K) dvisc = (18.05 + ((Tavg - 290.0) / 10.0) * (18.53 - 18.05)) * 1.0e-6; // dynamic viscosity (kg/m.sec) or (N.sec/m2) Cp = 1044.66 - 0.31597 * Tavg + 0.000707908 * pow_2(Tavg) - 0.00000027034 * pow_3(Tavg); @@ -6072,7 +6072,7 @@ void GLtoAMB(EnergyPlusData const &state, // properties of AIR rho = state.dataWindowEquivalentLayer->PAtmSeaLevel / (287.097 * Tavg); // density (kg/m3) <- temperature in (K) - beta = 1.0 / Tavg; // thermal expansion coef(/K) + beta = 1.0 / Tavg; // thermal expansion coeff (/K) dvisc = (18.05 + ((Tavg - 290.0) / 10.0) * (18.53 - 18.05)) * 1.0e-6; // dynamic viscosity (kg/m.sec) or (N.sec/m2) Cp = 1044.66 - 0.31597 * Tavg + 0.000707908 * pow_2(Tavg) - 0.00000027034 * pow_3(Tavg); @@ -6215,7 +6215,7 @@ void ASHWAT_Solar(int const NL, // # of layers // Returns the optical properties of multi-layer fenestration system model given optical // properties of the layers // METHODOLOGY EMPLOYED: - // Ues combination net radiation method and TDMA solver + // Use combination net radiation method and TDMA solver // REFERENCES: // JOHN L. WRIGHT and NATHAN KOTEY (2006). Solar Absorption By each Element in a Glazing/Shading // Layer Array, ASHRAE Transactions, Vol. 112, Pt. 2. pp. 3-12. @@ -6564,7 +6564,7 @@ bool Specular_OffNormal(Real64 const THETA, // solar beam angle of incidence, fr // RE-ENGINEERED na // PURPOSE OF THIS FUNCTION: - // Returns ratio of off-normal to normal of opetical properties. + // Returns ratio of off-normal to normal of optical properties. // METHODOLOGY EMPLOYED: // Uses a reference glass property. // returns TRUE if RAT_TAU < 1 or RAT_1MR < 1 (and thus Specular_Adjust s/b called) @@ -6934,7 +6934,7 @@ bool IS_SWP(EnergyPlusData &state, // front IS_BEAM(state, THETA, RHOFF_BT0, TAUFF_BT0, L.SWP_MAT.TAUSFBB, LSWP.RHOSFBD, LSWP.TAUSFBB, LSWP.TAUSFBD); - // back -- call with reverse material properies + // back -- call with reverse material properties IS_BEAM(state, THETA, RHOBF_BT0, TAUBF_BT0, L.SWP_MAT.TAUSBBB, LSWP.RHOSBBD, LSWP.TAUSBBB, LSWP.TAUSBBD); return true; @@ -7042,7 +7042,7 @@ bool PD_SWP(EnergyPlusData &state, CFSLAYER const &L, // PD layer CFSSWP &LSWP, // returned: equivalent layer properties set const Real64 OHM_V_RAD, // vertical VB profile angles, radians - const Real64 OHM_H_RAD // horizonatl VB profile angles, radians + const Real64 OHM_H_RAD // horizontal VB profile angles, radians ) { // FUNCTION INFORMATION: @@ -7081,7 +7081,7 @@ bool PD_SWP(EnergyPlusData &state, LSWP.TAUSFBB, LSWP.TAUSFBD); - // drape back properties: call with reversed fabric properies + // drape back properties: call with reversed fabric properties PD_BEAM(state, L.S, L.W, @@ -7509,7 +7509,7 @@ void BuildGap(EnergyPlusData &state, // PURPOSE OF THIS SUBROUTINE: // fills in the effective gap thickness and calculates the gas density - // The gas density is calculated at a standard manufactuered condition + // The gas density is calculated at a standard manufactured condition // if a different condition is not specified. // SUBROUTINE ARGUMENT DEFINITIONS: @@ -7541,7 +7541,7 @@ void AdjustVBGap(CFSGAP &G, // gap, returned updated // AUTHOR ASHRAE 1311-RP // PURPOSE OF THIS SUBROUTINE: - // Adjusts thickness of adjacent gaps seperated by in between slatted blind. + // Adjusts thickness of adjacent gaps separated by in between slatted blind. // METHODOLOGY EMPLOYED: // Treat VB layer as if it has 70% of actual thickness @@ -7595,7 +7595,7 @@ int CFSHasControlledShade(EnergyPlusData const &state, CFSTY const &FS) // FUNCTION INFORMATION: // AUTHOR ASHRAE 1311-RP // PURPOSE OF THIS FUNCTION: - // Returns index of the controlled layer in a fenestratio. If no + // Returns index of the controlled layer in a fenestration. If no // controlled layer, then returns zero. int CFSHasControlledShade = 0; @@ -7921,8 +7921,8 @@ Real64 EQLWindowInsideEffectiveEmiss(EnergyPlusData &state, int const ConstrNum) // DATE WRITTEN May 2013 // PURPOSE OF THIS FUNCTION: - // Given the consruction number, returns the equivalent layer inside - // face effective longwave emmisivity. + // Given the construction number, returns the equivalent layer inside + // face effective longwave emissivity. return EffectiveEPSLB(state.dataWindowEquivLayer->CFS(state.dataConstruction->Construct(ConstrNum).EQLConsPtr)); } @@ -7934,8 +7934,8 @@ Real64 EQLWindowOutsideEffectiveEmiss(EnergyPlusData &state, int const ConstrNum // DATE WRITTEN May 2013 // PURPOSE OF THIS FUNCTION: - // Given the consruction number, returns the equivalent layer outside - // face effective longwave emmisivity. + // Given the construction number, returns the equivalent layer outside + // face effective longwave emissivity. int EQLNum = state.dataConstruction->Construct(ConstrNum).EQLConsPtr; return EffectiveEPSLF(state.dataWindowEquivLayer->CFS(EQLNum)); diff --git a/src/EnergyPlus/WindowManager.cc b/src/EnergyPlus/WindowManager.cc index 793ca54ed47..09db05a68fd 100644 --- a/src/EnergyPlus/WindowManager.cc +++ b/src/EnergyPlus/WindowManager.cc @@ -646,7 +646,7 @@ namespace Window { if (TotalIPhi > maxIncidentAngles) { ShowSevereError(state, - format("WindowManage::InitGlassOpticalCalculations = {}, Invalid maximum value of common incidet angles = {}.", + format("WindowManage::InitGlassOpticalCalculations = {}, Invalid maximum value of common incident angles = {}.", thisConstruct.Name, TotalIPhi)); ShowContinueError( @@ -715,7 +715,7 @@ namespace Window { std::array stPhi = {0.0}; // Glazing system transmittance at angle of incidence for each wavelength in wle std::array srfPhi = {0.0}; // Glazing system front reflectance at angle of incidence for each wavelength in wle - std::array srbPhi = {0.0}; // Glazing system back reflectance at angle of incidence for each wavelenth in wle + std::array srbPhi = {0.0}; // Glazing system back reflectance at angle of incidence for each wavelength in wle // For each layer, glazing system absorptance at angle of incidence Array2D saPhi(maxGlassLayers, nume, 0.0); @@ -901,7 +901,7 @@ namespace Window { // stPhi, srfPhi, srbPhi and saPhi at this angle of incidence std::array stPhi = {0.0}; // Glazing system transmittance at angle of incidence for each wavelength in wle std::array srfPhi = {0.0}; // Glazing system front reflectance at angle of incidence for each wavelength in wle - std::array srbPhi = {0.0}; // Glazing system back reflectance at angle of incidence for each wavelenth in wle + std::array srbPhi = {0.0}; // Glazing system back reflectance at angle of incidence for each wavelength in wle // For each layer, glazing system absorptance at angle of incidence Array2D saPhi(maxGlassLayers, nume, 0.0); @@ -2091,7 +2091,7 @@ namespace Window { Real64 Tright; Real64 SrdSurfTempAbs; // Absolute temperature of a surrounding surface - Real64 OutSrdIR; // LWR from surrouding srfs + Real64 OutSrdIR; // LWR from surrounding srfs // New variables for thermochromic windows calc Real64 locTCSpecTemp; // The temperature corresponding to the specified optical properties of the TC layer @@ -2207,7 +2207,7 @@ namespace Window { // Reset hcin if necessary since too small a value sometimes causes non-convergence // of window layer heat balance solution. if (s_surf->surfIntConv(SurfNum).model == Convect::HcInt::SetByZone) { - // may be redundent now, check is also in HeatBalanceConvectionCoeffs.cc + // may be redundant now, check is also in HeatBalanceConvectionCoeffs.cc if (wm->hcin <= state.dataHeatBal->LowHConvLimit) { // hcin = 3.076d0 !BG this is rather high value and abrupt change. changed to set to lower limit wm->hcin = state.dataHeatBal->LowHConvLimit; @@ -3695,7 +3695,7 @@ namespace Window { int ConstrNumSh; // Shaded construction number int MatNumSh; // Material number of shade/blind layer - int nglassfaces; // Number of glass faces in contruction + int nglassfaces; // Number of glass faces in construction Real64 TGapInlet; // Temperature of air entering glass-shade/blind gap at bottom for upward // air flow or top for downward air flow (K) Real64 TGlassFace; // Temperature of glass surface facing glass-shade/blind gap (K) @@ -4539,9 +4539,9 @@ namespace Window { cpmixm += frct[i - 1] * fcp[i - 1] * wmgas.wght; // eq. 58-59 kprime[i - 1] = 3.75 * gaslaw / wmgas.wght * fvis[i - 1]; // eq. 67 kdblprm[i - 1] = fcon[i - 1] - kprime[i - 1]; // eq. 68 - mukpdwn[i - 1] = 1.0; // initialize denomonator of eq. 60 - kpdown[i - 1] = 1.0; // initialize denomonator of eq. 63 - kdpdown[i - 1] = 1.0; // initialize denomonator of eq. 65 + mukpdwn[i - 1] = 1.0; // initialize denominator of eq. 60 + kpdown[i - 1] = 1.0; // initialize denominator of eq. 63 + kdpdown[i - 1] = 1.0; // initialize denominator of eq. 65 } for (int i = 1; i <= NMix; ++i) { @@ -4552,18 +4552,18 @@ namespace Window { // numerator of equation 61 phimup = pow_2(1.0 + std::sqrt(fvis[i - 1] / fvis[j - 1]) * root_4(wmgasJ.wght / wmgasI.wght)); - // denomonator of eq. 61, 64 and 66 + // denominator of eq. 61, 64 and 66 downer = two_sqrt_2 * std::sqrt(1 + (wmgasI.wght / wmgasJ.wght)); // calculate the denominator of eq. 60 if (i != j) mukpdwn[i - 1] += phimup / downer * frct[j - 1] / frct[i - 1]; - // numerator of eq. 64; psiterm is the multiplied term in backets + // numerator of eq. 64; psiterm is the multiplied term in brackets psiup = pow_2(1.0 + std::sqrt(kprime[i - 1] / kprime[j - 1]) * root_4(wmgasI.wght / wmgasJ.wght)); psiterm = 1.0 + 2.41 * (wmgasI.wght - wmgasJ.wght) * (wmgasI.wght - 0.142 * wmgasJ.wght) / pow_2(wmgasI.wght + wmgasJ.wght); // using the common denominator, downer, calculate the denominator for eq. 63 if (i != j) kpdown[i - 1] += psiup * (psiterm / downer) * (frct[j - 1] / frct[i - 1]); // calculate the numerator of eq. 66 phikup = pow_2(1.0 + std::sqrt(kprime[i - 1] / kprime[j - 1]) * root_4(wmgasI.wght / wmgasJ.wght)); - // using the common denominator, downer, calculate the denomonator for eq. 65 + // using the common denominator, downer, calculate the denominator for eq. 65 if (i != j) kdpdown[i - 1] += (phikup / downer) * (frct[j - 1] / frct[i - 1]); } mumix += fvis[i - 1] / mukpdwn[i - 1]; // eq. 60 @@ -4660,7 +4660,7 @@ namespace Window { fvis(i) = wmgas.vis.c0 + wmgas.vis.c1 * tmean + wmgas.vis.c2 * tmean_2; fdens(i) = pres * wmgas.wght / (gaslaw * tmean); molmix += frct(i) * wmgas.wght; // eq. 56 - mukpdwn(i) = 1.0; // initialize denomonator of eq. 60 + mukpdwn(i) = 1.0; // initialize denominator of eq. 60 } for (int i = 1; i <= NMix; ++i) { @@ -4669,7 +4669,7 @@ namespace Window { auto const &wmgasJ = wm->gaps[IGap - 1].gases[j - 1]; // numerator of equation 61 phimup = pow_2(1.0 + std::sqrt(fvis(i) / fvis(j)) * root_4(wmgasJ.wght / wmgasI.wght)); - // denomonator of eq. 61, 64 and 66 + // denominator of eq. 61, 64 and 66 downer = two_sqrt_2 * std::sqrt(1 + (wmgasI.wght / wmgasJ.wght)); // calculate the denominator of eq. 60 if (i != j) mukpdwn(i) += phimup / downer * frct(j) / frct(i); @@ -5478,7 +5478,7 @@ namespace Window { int const N, // Order of polynomial int const N1, // First and last data points used int const N2, - Array1S CoeffsCurve // Polynomial coeffients from fit + Array1S CoeffsCurve // Polynomial coefficients from fit ) { @@ -5543,7 +5543,7 @@ namespace Window { } } - // Perform back substituion + // Perform back substitution CoeffsCurve(N) = B(N) / A(N, N); LP1 = N; int L = N - 1; @@ -5637,7 +5637,7 @@ namespace Window { } } - // Perform back substituion + // Perform back substitution CoeffsCurve(N) = B(N) / A(N, N); LP1 = N; int L = N - 1; @@ -5679,7 +5679,7 @@ namespace Window { // Locals // SUBROUTINE ARGUMENT DEFINITIONS: - // 0,10,20,...,80,90 degress + // 0,10,20,...,80,90 degrees Real64 const DPhiR(10.0 * Constant::DegToRadians); // Half of 10-deg incidence angle increment (radians) @@ -5759,7 +5759,7 @@ namespace Window { int TotLayers; // Total number of layers in unshaded construction // Real64 DivTempOut; // Outside surface divider temperature (K) Real64 FrameHeatGain; // Heat gain to zone from frame (W) - // Real64 FrameHeatTransfer; // Heat tansfer through frame (W) + // Real64 FrameHeatTransfer; // Heat transfer through frame (W) // Real64 ProjCorrWinHeatGain; // Inside projection correction to IR from divider to zone // for window heat gain calculation Real64 DividerHeatGain; // Heat gain to zone from divider (W) @@ -6427,7 +6427,7 @@ namespace Window { } } - // Need to add variables writing here since this routine will override previously calcualted values from WinCalc-Engine + // Need to add variables writing here since this routine will override previously calculated values from WinCalc-Engine if (wm->inExtWindowModel->isExternalLibraryModel()) { TSolNorm = GetSolarTransDirectHemispherical(state, ConstrNum); TVisNorm = GetVisibleTransDirectHemispherical(state, ConstrNum); @@ -6514,7 +6514,7 @@ namespace Window { void WindowTempsForNominalCond(EnergyPlusData &state, int const ConstrNum, // Construction number Array1A hgap, // Gap gas conductive conductance (W/m2-K) - Real64 const adjRatio // adjusment Ratio to hcin + Real64 const adjRatio // adjustment Ratio to hcin ) { @@ -6538,7 +6538,7 @@ namespace Window { // This is a shortened form of SolveForWindowTemperatures tailored // for calculation of the nominal center-of-glass U-value for a window // construction at ASHRAE winter conditions and for determining conditions at - // summer conditions for calculationg SHGC. + // summer conditions for calculating SHGC. // Evaluates the coefficients Aface and Bface in the system of linear // algebraic equations // Sum [Aface(i,j)*thetas(j)] = Bface(i), i = 1,nglface @@ -7256,7 +7256,7 @@ namespace Window { // In the time-step calculation,the blind properties vs. profile angle and slat angle // that are calculated here will be applicable to windows and slats - // of arbitrary orientation, and to arbitrary sun positions, as long as the appropiate + // of arbitrary orientation, and to arbitrary sun positions, as long as the appropriate // profile angle is used. The slat angle for a particular window with blinds is determined // each time step in subroutine WindowShadingManager on the basis of user-specified // slat control options. @@ -7522,7 +7522,7 @@ namespace Window { assert(matScreen != nullptr); s_surf->SurfaceWindow(SurfNum).screenNum = MatNum; - if (matScreen->isUsed) continue; // Has already been initalized + if (matScreen->isUsed) continue; // Has already been initialized matScreen->isUsed = true; if (matScreen->mapDegResolution > 0) PrintTransMap = true; diff --git a/src/EnergyPlus/WindowManagerExteriorThermal.cc b/src/EnergyPlus/WindowManagerExteriorThermal.cc index d4b1883ff26..a38427b7ff9 100644 --- a/src/EnergyPlus/WindowManagerExteriorThermal.cc +++ b/src/EnergyPlus/WindowManagerExteriorThermal.cc @@ -606,7 +606,7 @@ namespace Window { assert(matScreen != nullptr); // Simon: Existing code already takes into account geometry of Woven and scales down - // emissivity for openning area. + // emissivity for opening area. emissFront = matScreen->AbsorpThermal; emissBack = matScreen->AbsorpThermal; transThermalFront = matScreen->TransThermal; diff --git a/src/EnergyPlus/ZoneEquipmentManager.cc b/src/EnergyPlus/ZoneEquipmentManager.cc index 27f89d9398a..cdf44df253a 100644 --- a/src/EnergyPlus/ZoneEquipmentManager.cc +++ b/src/EnergyPlus/ZoneEquipmentManager.cc @@ -425,7 +425,7 @@ void sizeZoneSpaceEquipmentPart1(EnergyPlusData &state, // Sign convention: SysOutputProvided <0 Supply air is heated on entering zone (zone is cooled) // SysOutputProvided >0 Supply air is cooled on entering zone (zone is heated) if (!state.dataZoneEnergyDemand->DeadBandOrSetback(zoneNum) && std::abs(zsEnergyDemand.RemainingOutputRequired) > HVAC::SmallLoad) { - // Determine design supply air temperture and design supply air temperature difference + // Determine design supply air temperature and design supply air temperature difference if (zsEnergyDemand.RemainingOutputRequired < 0.0) { // Cooling case // If the user specify the design cooling supply air temperature, then if (zsCalcSizing.ZnCoolDgnSAMethod == SupplyAirTemperature) { diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.cc b/src/EnergyPlus/ZoneTempPredictorCorrector.cc index bfd6a4138c3..445bccd323f 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.cc +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.cc @@ -2050,11 +2050,11 @@ void GetZoneAirSetPoints(EnergyPlusData &state) OutputProcessor::StoreType::Average, state.dataHeatBal->Zone(TempControlledZone.ActualZoneNum).Name); } // TStat Objects Loop - } // found thermostat referene + } // found thermostat reference } // loop over NumOpTempControlledZones } // NumOpTempControlledZones > 0 - // Overcool dehumidificaton GetInput starts here + // Overcool dehumidification GetInput starts here cCurrentModuleObject = cZControlTypes(static_cast(ZoneControlTypes::TandHStat)); state.dataZoneCtrls->NumTempAndHumidityControlledZones = inputProcessor->getNumObjectsFound(state, cCurrentModuleObject); @@ -2477,7 +2477,7 @@ void GetZoneAirSetPoints(EnergyPlusData &state) cAlphaArgs(1), cNumericFieldNames(8), rNumericArgs(8))); - ShowContinueError(state, ".. The minumum value is 0."); + ShowContinueError(state, ".. The minimum value is 0."); ErrorsFound = true; } @@ -3436,7 +3436,7 @@ void PredictSystemLoads(EnergyPlusData &state, thisZoneThermostatSetPointLo = thisTempControlledZone.ZoneThermostatSetPointLo; thisTempControlledZone.HeatOffFlag = true; } - // check setpoint for both and provde an error message + // check setpoint for both and provide an error message if (thisZoneThermostatSetPointLo >= thisZoneThermostatSetPointHi) { ShowSevereError(state, "DualSetPointWithDeadBand: When Temperature Difference Between Cutout And Setpoint is applied, the heating " @@ -3770,7 +3770,7 @@ void CalcZoneAirTempSetPoints(EnergyPlusData &state) break; } - // Apply offset for faulty therostats + // Apply offset for faulty thermostats if ((state.dataFaultsMgr->NumFaultyThermostat > 0) && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) && (!state.dataGlobal->KickOffSimulation)) { // loop through the FaultsThermostatOffset objects to find the one for the zone @@ -4167,7 +4167,7 @@ Real64 correctZoneAirTemps(EnergyPlusData &state, Real64 spaceTempChange = thisSpaceHB.correctAirTemp(state, useZoneTimeStepHistory, zoneNum, spaceNum); maxTempChange = max(maxTempChange, spaceTempChange); } else { - // If doing sizing and zone is controled, then set space node to match zone node + // If doing sizing and zone is controlled, then set space node to match zone node if (state.dataHeatBal->doSpaceHeatBalanceSizing && thisZone.IsControlled) { auto const &thisZoneNode = state.dataLoopNodes->Node(thisZone.SystemZoneNodeNumber); auto &thisSpaceNode = state.dataLoopNodes->Node(state.dataHeatBal->space(spaceNum).SystemZoneNodeNumber); @@ -5170,7 +5170,7 @@ void InverseModelTemperature(EnergyPlusData &state, (TempIndCoef - TempDepCoef * thisZoneHB.ZT); } - if ((AirCapHM_temp > 0) && (AirCapHM_temp != 1)) { // Avoide IND + if ((AirCapHM_temp > 0) && (AirCapHM_temp != 1)) { // Avoid IND AirCapHM = TempDepCoef / std::log(AirCapHM_temp); // Inverse equation } else { AirCapHM = TempIndCoef / (thisZoneHB.ZT - state.dataHeatBalFanSys->PreviousMeasuredZT1(ZoneNum)); @@ -5195,7 +5195,7 @@ void InverseModelTemperature(EnergyPlusData &state, state, MultpHM, zone.ZoneVolCapMultpSensHMSum, zone.ZoneVolCapMultpSensHMCountSum, zone.ZoneVolCapMultpSensHMAverage, ZoneNum); zone.ZoneVolCapMultpSensHM = MultpHM; - } // Hybrid model internal thermal mass calcualtion end + } // Hybrid model internal thermal mass calculation end // Hybrid model people count calculation if (hybridModelZone.PeopleCountCalc_T && state.dataHVACGlobal->UseZoneTimeStepHistory) { @@ -5272,7 +5272,7 @@ void processInverseModelMultpHM(EnergyPlusData &state, Real64 &multiplierHM, // Hybrid model thermal mass multiplier Real64 &multSumHM, // Sum of Hybrid model thermal mass multipliers Real64 &countSumHM, // Count of number of points in sum - Real64 &multAvgHM, // Average of hybrid model mass multipier + Real64 &multAvgHM, // Average of hybrid model mass multiplier int zoneNum // Zone number for the hybrid model ) { @@ -6252,7 +6252,7 @@ void CalcZoneAirComfortSetPoints(EnergyPlusData &state) // DATE WRITTEN May 2006 // PURPOSE OF THIS SUBROUTINE: - // This routine sets the thermal comfort setpoints for each controlled zone based on air tempeature obtained from thermal comfort models. + // This routine sets the thermal comfort setpoints for each controlled zone based on air temperature obtained from thermal comfort models. // SUBROUTINE LOCAL VARIABLE DECLARATIONS: Real64 SetPointLo = 0.0; @@ -6950,7 +6950,7 @@ temperatureAndCountInSch(EnergyPlusData &state, int const scheduleIndex, bool co { // J.Glazer - Aug 2017 - // determine month to use based on hemiphere and season + // determine month to use based on hemisphere and season int monthToUse; if (isSummer) { if (state.dataEnvrn->Latitude > 0.) { From 831c957615b714cb8342b0b9d64f51d185f22861 Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 08:51:04 -0600 Subject: [PATCH 04/12] Fix typos in tst. --- tst/EnergyPlus/unit/ConvectionCoefficients.unit.cc | 10 +++++----- tst/EnergyPlus/unit/DataHeatBalance.unit.cc | 2 +- tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc | 4 ++-- tst/EnergyPlus/unit/MixedAir.unit.cc | 2 +- tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc | 6 +++--- tst/EnergyPlus/unit/Psychrometrics.unit.cc | 8 ++++---- tst/EnergyPlus/unit/SimulationManager.unit.cc | 4 ++-- tst/EnergyPlus/unit/WindowEquivalentLayer.unit.cc | 2 +- tst/EnergyPlus/unit/XingGroundTemperatureModel.unit.cc | 2 +- tst/EnergyPlus/unit/ZoneEquipmentManager.unit.cc | 4 ++-- 10 files changed, 22 insertions(+), 22 deletions(-) diff --git a/tst/EnergyPlus/unit/ConvectionCoefficients.unit.cc b/tst/EnergyPlus/unit/ConvectionCoefficients.unit.cc index 69790886002..a3c1c88615b 100644 --- a/tst/EnergyPlus/unit/ConvectionCoefficients.unit.cc +++ b/tst/EnergyPlus/unit/ConvectionCoefficients.unit.cc @@ -1385,7 +1385,7 @@ TEST_F(ConvectionCoefficientsFixture, TestCalcFisherPedersenCeilDiffuserCorrelat CalculatedHconv = Convect::CalcFisherPedersenCeilDiffuserWalls(*state, ACH, Tsurf, Tair, cosTilt, humRat, height, isWindow); EXPECT_NEAR(ExpectedHconv, CalculatedHconv, 0.0001); - // Test 3: Mixed Covection All Correlations (Floor, Ceiling, Wall) + // Test 3: Mixed Convection All Correlations (Floor, Ceiling, Wall) ACH = 1.75; Tsurf = 23.0; Tair = 18.0; @@ -4047,11 +4047,11 @@ TEST_F(ConvectionCoefficientsFixture, SurroundingSurfacesHRadCoefTest) Real64 srdSurfacesViewFactorSum_result1 = srdSurfsProperty_north.SurroundingSurfs(1).ViewFactor + srdSurfsProperty_north.SurroundingSurfs(2).ViewFactor; EXPECT_DOUBLE_EQ(0.5, srdSurfacesViewFactorSum_result1); - // calculate surrounding surface radiation coeffient + // calculate surrounding surface radiation coefficient Real64 surf_tempExtK = state->dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum) + Constant::Kelvin; auto &north_wall_const = state->dataConstruction->Construct(surface_north_wall.Construction); auto const *north_wall_mat = state->dataMaterial->materials(north_wall_const.LayerPoint(1)); - Real64 surf_absExt_north_wall = north_wall_mat->AbsorpThermal; // LW emitance of the exterior surface + Real64 surf_absExt_north_wall = north_wall_mat->AbsorpThermal; // LW emittance of the exterior surface // calculate surrounding surfaces radiation exchange coefficient Real64 north_wall_srdSurfsTK = surface_north_wall.SrdSurfTemp + Constant::Kelvin; EXPECT_NEAR(10.80, surface_north_wall.SrdSurfTemp, 1.0e-02); @@ -4086,11 +4086,11 @@ TEST_F(ConvectionCoefficientsFixture, SurroundingSurfacesHRadCoefTest) Real64 srdSurfacesViewFactorSum_result2 = srdSurfsProperty_east.SurroundingSurfs(1).ViewFactor + srdSurfsProperty_east.SurroundingSurfs(2).ViewFactor; EXPECT_DOUBLE_EQ(0.3, srdSurfacesViewFactorSum_result2); - // calculate surrounding surface radiation coeffient + // calculate surrounding surface radiation coefficient surf_tempExtK = state->dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum) + Constant::Kelvin; auto &east_wall_const = state->dataConstruction->Construct(surface_east_wall.Construction); auto const *east_wall_mat = state->dataMaterial->materials(east_wall_const.LayerPoint(1)); - Real64 surf_absExt_east_wall = east_wall_mat->AbsorpThermal; // LW emitance of the exterior surface + Real64 surf_absExt_east_wall = east_wall_mat->AbsorpThermal; // LW emittance of the exterior surface // calculate surrounding surfaces radiation exchange coefficient Real64 east_wall_srdSurfsTK = surface_east_wall.SrdSurfTemp + Constant::Kelvin; EXPECT_NEAR(15.34, surface_east_wall.SrdSurfTemp, 1.0e-02); diff --git a/tst/EnergyPlus/unit/DataHeatBalance.unit.cc b/tst/EnergyPlus/unit/DataHeatBalance.unit.cc index b8b0ecaf334..57a5f5408f8 100644 --- a/tst/EnergyPlus/unit/DataHeatBalance.unit.cc +++ b/tst/EnergyPlus/unit/DataHeatBalance.unit.cc @@ -873,7 +873,7 @@ TEST_F(EnergyPlusFixture, DataHeatBalance_CheckConstructLayers) state->dataConstruction->Construct(4).LayerPoint(3) = 6; // window blind state->dataConstruction->Construct(4).LayerPoint(4) = 5; // air gap state->dataConstruction->Construct(4).LayerPoint(5) = 4; // glass - // updated contruction and material layers data + // updated construction and material layers data EXPECT_EQ(state->dataConstruction->Construct(4).TotLayers, 5); // outer glass, air gap, blind, air gap, inner glass EXPECT_EQ(state->dataConstruction->Construct(4).TotGlassLayers, 2); // outer glass, inner glass EXPECT_EQ(state->dataConstruction->Construct(4).TotSolidLayers, 3); // glass, blind, glass diff --git a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc index ecab9c6fdcd..3142a3e39fc 100644 --- a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc @@ -1325,7 +1325,7 @@ TEST_F(EnergyPlusFixture, HVACMultiSpeedHeatPump_ReportVariableInitTest) state->dataHVACMultiSpdHP->MSHeatPump(2).TotCoolEnergyRate = 1000.0; state->dataHVACMultiSpdHP->MSHeatPump(1).FlowFraction = 1.0; state->dataHVACMultiSpdHP->MSHeatPump(2).FlowFraction = 1.0; - // because sizing isn't occuring, we must set these + // because sizing isn't occurring, we must set these for (auto &dxCoil : state->dataDXCoils->DXCoil) { for (int i = 1; i <= dxCoil.NumOfSpeeds; ++i) { dxCoil.MSRatedAirMassFlowRate(i) = dxCoil.MSRatedAirVolFlowRate(i) * 1.2; @@ -2218,7 +2218,7 @@ TEST_F(EnergyPlusFixture, HVACMSHP_UnitarySystemElectricityRateTest) zoneAirNode.Temp = 21.1; zoneAirNode.HumRat = 0.0035; zoneAirNode.Enthalpy = Psychrometrics::PsyHFnTdbW(zoneAirNode.Temp, zoneAirNode.HumRat); - // set maixed air node conditions + // set mixed air node conditions auto &mixedAirNode = state->dataLoopNodes->Node(Util::FindItemInList("AC-24 SF INLET AIR NODE", state->dataLoopNodes->NodeID, state->dataLoopNodes->NumOfNodes)); mixedAirNode.Temp = 10.0; diff --git a/tst/EnergyPlus/unit/MixedAir.unit.cc b/tst/EnergyPlus/unit/MixedAir.unit.cc index 01bdbee4868..0c1cf4fdb08 100644 --- a/tst/EnergyPlus/unit/MixedAir.unit.cc +++ b/tst/EnergyPlus/unit/MixedAir.unit.cc @@ -5869,7 +5869,7 @@ TEST_F(EnergyPlusFixture, MechVentController_VRPCap) OAMassFlow = state->dataMixedAir->VentilationMechanical(1).CalcMechVentController(*state, SysMassFlow); EXPECT_NEAR( - ExpectedOAMassFlow, OAMassFlow, 0.001); // Expect to cap the system OA to the desing OA air flow, OAMassFlow without the cap is ~0.86 m3/s + ExpectedOAMassFlow, OAMassFlow, 0.001); // Expect to cap the system OA to the design OA air flow, OAMassFlow without the cap is ~0.86 m3/s } TEST_F(EnergyPlusFixture, MechVentController_VRPNoCap) diff --git a/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc b/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc index 7487dcafe92..64e7d34ee06 100644 --- a/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc @@ -544,7 +544,7 @@ TEST_F(EnergyPlusFixture, DISABLED_PackagedTerminalHP_VSCoils_Sizing) EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "LOBBY_ZN_1_FLR_2 WSHP COOLING MODE"); // PTHP sized the VS coil differently. The PTHP uses the design air flow to size VS coil capacity - // then back calulates air flow rate. The PTHP would read the coil air flow and capacity and report + // then back calculates air flow rate. The PTHP would read the coil air flow and capacity and report // those values to the eio. The UnitarySystem sizes the air flow rate and then calls the VS coil, // which sizes, and uses the VS coil capacity to report UnitarySystem capacity to the eio. // This requires and issue to correct. @@ -1297,7 +1297,7 @@ TEST_F(EnergyPlusFixture, SimPTAC_SZVAVTest) ASSERT_NEAR(state->dataHeatingCoils->HeatingCoil(1).HeatingCoilRate, 2668.1427, 0.0001); // Boundary load for this system in Region 1 at minimum air flow rate is 2006.8 W (lower boundary load in Region 1) - // loads below the bounday load should operate at the minimum air flow rate + // loads below the boundary load should operate at the minimum air flow rate // set heating load to non-zero value below lower boundary load state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).RemainingOutputRequired = 1000.0; state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).RemainingOutputReqToHeatSP = 1000.0; @@ -1336,7 +1336,7 @@ TEST_F(EnergyPlusFixture, SimPTAC_SZVAVTest) // Boundary load for this system in Region 1 at maximum air flow rate is 2995.2 W // system should operate at maximum air flow rate for loads greater than 2995.2 W - // outlet air temperture is allowed to be above the design maximum supply air temperature in heating mode + // outlet air temperature is allowed to be above the design maximum supply air temperature in heating mode state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).RemainingOutputRequired = 3000.0; // set heating load to just above upper boundary load state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).RemainingOutputReqToHeatSP = 3000.0; thisSys.simulate(*state, thisSys.Name, FirstHVACIteration, 0, PTUnitNum, HeatActive, CoolActive, 0, 0, true, QUnitOut, latOut); diff --git a/tst/EnergyPlus/unit/Psychrometrics.unit.cc b/tst/EnergyPlus/unit/Psychrometrics.unit.cc index 2213c9858a0..2fa0faae81e 100644 --- a/tst/EnergyPlus/unit/Psychrometrics.unit.cc +++ b/tst/EnergyPlus/unit/Psychrometrics.unit.cc @@ -380,8 +380,8 @@ TEST_F(EnergyPlusFixture, Psychrometrics_CpAirValue_Test) Real64 Qfrom_mdot_CpAir_DeltaT = MassFlowRate * CpAir * (T1 - T2); // get enthalpy at state 1 and 2 - Real64 H1 = PsyHFnTdbW(T1, W1); // enthaly ait state 1 - Real64 H2 = PsyHFnTdbW(T2, W2); // enthaly ait state 2 + Real64 H1 = PsyHFnTdbW(T1, W1); // enthalpy air state 1 + Real64 H2 = PsyHFnTdbW(T2, W2); // enthalpy air state 2 Real64 Qfrom_mdot_DeltaH = MassFlowRate * (H1 - H2); // check heat rate @@ -393,8 +393,8 @@ TEST_F(EnergyPlusFixture, Psychrometrics_CpAirValue_Test) CpAir = 1.00484e3 + W1 * 1.85895e3; Qfrom_mdot_CpAir_DeltaT = MassFlowRate * CpAir * (T2 - T1); - H1 = PsyHFnTdbW(T1, W1); // enthaly ait state 1 - H2 = PsyHFnTdbW(T2, W2); // enthaly ait state 2 + H1 = PsyHFnTdbW(T1, W1); // enthalpy air state 1 + H2 = PsyHFnTdbW(T2, W2); // enthalpy air state 2 Qfrom_mdot_DeltaH = MassFlowRate * (H2 - H1); // check heat transfer rate calc method for heating diff --git a/tst/EnergyPlus/unit/SimulationManager.unit.cc b/tst/EnergyPlus/unit/SimulationManager.unit.cc index 954b4afae02..896fb3887c9 100644 --- a/tst/EnergyPlus/unit/SimulationManager.unit.cc +++ b/tst/EnergyPlus/unit/SimulationManager.unit.cc @@ -125,7 +125,7 @@ TEST_F(EnergyPlusFixture, Simulationmanager_bool_to_string) EXPECT_EQ(SimulationManager::bool_to_string(false), "False"); } -TEST_F(EnergyPlusFixture, Simulationmanager_writeIntialPerfLogValues) +TEST_F(EnergyPlusFixture, Simulationmanager_writeInitialPerfLogValues) { state->dataStrGlobals->outputPerfLogFilePath = "eplusout_perflog.csv"; @@ -136,7 +136,7 @@ TEST_F(EnergyPlusFixture, Simulationmanager_writeIntialPerfLogValues) Util::appendPerfLog(*state, "RESET", "RESET"); // call the function to test - SimulationManager::writeIntialPerfLogValues(*state, "MODE193"); + SimulationManager::writeInitialPerfLogValues(*state, "MODE193"); // force the file to be written Util::appendPerfLog(*state, "lastHeader", "lastValue", true); diff --git a/tst/EnergyPlus/unit/WindowEquivalentLayer.unit.cc b/tst/EnergyPlus/unit/WindowEquivalentLayer.unit.cc index f139375a41e..17cc176a2d0 100644 --- a/tst/EnergyPlus/unit/WindowEquivalentLayer.unit.cc +++ b/tst/EnergyPlus/unit/WindowEquivalentLayer.unit.cc @@ -1973,7 +1973,7 @@ TEST_F(EnergyPlusFixture, WindowEquivalentLayer_VBEffectiveEmissivityTest) // get venetian blind material index int VBMatNum = Material::GetMaterialNum(*state, "WMTEUQL_BLND_KINDV_RF80_T02_A18_Rb45"); auto const *matVenetBlind = dynamic_cast(state->dataMaterial->materials(VBMatNum)); - // get equivalent layer window contruction index + // get equivalent layer window construction index for (int ConstrPtr = 1; ConstrPtr <= state->dataHeatBal->TotConstructs; ++ConstrPtr) { if (state->dataConstruction->Construct(ConstrPtr).WindowTypeEQL) { ConstrNum = ConstrPtr; diff --git a/tst/EnergyPlus/unit/XingGroundTemperatureModel.unit.cc b/tst/EnergyPlus/unit/XingGroundTemperatureModel.unit.cc index 0f4655d0fb0..d298dc513e7 100644 --- a/tst/EnergyPlus/unit/XingGroundTemperatureModel.unit.cc +++ b/tst/EnergyPlus/unit/XingGroundTemperatureModel.unit.cc @@ -67,7 +67,7 @@ TEST_F(EnergyPlusFixture, XingGroundTempsModelTest) " 1.08, !- Soil Thermal Conductivity {W/m-K}", " 962, !- Soil Density {kg/m3}", " 2576, !- Soil Specific Heat {J/kg-K}", - " 11.1, !- Average Soil Surface Tempeature {C}", + " 11.1, !- Average Soil Surface Temperature {C}", " 13.4, !- Soil Surface Temperature Amplitude 1 {deltaC}", " 0.7, !- Soil Surface Temperature Amplitude 2 {deltaC}", " 25, !- Phase Shift of Temperature Amplitude 1 {days}", diff --git a/tst/EnergyPlus/unit/ZoneEquipmentManager.unit.cc b/tst/EnergyPlus/unit/ZoneEquipmentManager.unit.cc index 86ba25331bb..3eec55f2e20 100644 --- a/tst/EnergyPlus/unit/ZoneEquipmentManager.unit.cc +++ b/tst/EnergyPlus/unit/ZoneEquipmentManager.unit.cc @@ -1311,7 +1311,7 @@ TEST_F(EnergyPlusFixture, ZoneEquipmentManager_DistributeUniformPLR) // Set up capacities for PLR calcs state->dataSize->FinalZoneSizing.allocate(1); state->dataSize->FinalZoneSizing(ZoneNum).DesHeatLoad = 4000; - // For finalzonesizing, desing cooling load is positive + // For finalzonesizing, design cooling load is positive state->dataSize->FinalZoneSizing(ZoneNum).DesCoolLoad = 2500; auto &thisZEqList(state->dataZoneEquip->ZoneEquipList(ZoneNum)); thisZEqList.HeatingCapacity(1) = 2000.0; @@ -1533,7 +1533,7 @@ TEST_F(EnergyPlusFixture, ZoneEquipmentManager_DistributeSequentialUniformPLR) // Set up capacities for PLR calcs state->dataSize->FinalZoneSizing.allocate(1); state->dataSize->FinalZoneSizing(ZoneNum).DesHeatLoad = 4000; - // For finalzonesizing, desing cooling load is positive + // For finalzonesizing, design cooling load is positive state->dataSize->FinalZoneSizing(ZoneNum).DesCoolLoad = 2500; auto &thisZEqList(state->dataZoneEquip->ZoneEquipList(ZoneNum)); thisZEqList.HeatingCapacity(1) = 2000.0; From 3c2607fd255e81706e3b47656cf72697b0d68bcc Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 08:55:58 -0600 Subject: [PATCH 05/12] Another bugfix. --- src/EnergyPlus/HybridUnitaryAirConditioners.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EnergyPlus/HybridUnitaryAirConditioners.cc b/src/EnergyPlus/HybridUnitaryAirConditioners.cc index 99068b1b2e1..f55bcd834c0 100644 --- a/src/EnergyPlus/HybridUnitaryAirConditioners.cc +++ b/src/EnergyPlus/HybridUnitaryAirConditioners.cc @@ -1129,7 +1129,7 @@ void GetInputZoneHybridUnitaryAirConditioners(EnergyPlusData &state, bool &Error OutputProcessor::StoreType::Average, hybridUnitaryAC.Name); SetupOutputVariable(state, - "Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Transfer Energy", + "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Heat Transfer Energy", Constant::Units::J, hybridUnitaryAC.RequestedDeHumidificationEnergy, OutputProcessor::TimeStepType::System, From 7c0298157995d2a06277a263e79f38d1bf37c63a Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 10:41:48 -0600 Subject: [PATCH 06/12] More typos, apply clang. --- src/EnergyPlus/CondenserLoopTowers.cc | 6 +-- src/EnergyPlus/DaylightingDevices.cc | 4 +- src/EnergyPlus/EcoRoofManager.cc | 4 +- src/EnergyPlus/FuelCellElectricGenerator.cc | 42 +++++++++---------- src/EnergyPlus/HybridEvapCoolingModel.hh | 12 +++--- src/EnergyPlus/IceThermalStorage.cc | 8 ++-- .../InputProcessing/InputProcessor.cc | 8 ++-- src/EnergyPlus/MixedAir.cc | 16 +++---- src/EnergyPlus/OutdoorAirUnit.cc | 8 ++-- src/EnergyPlus/Plant/EquipAndOperations.cc | 12 +++--- src/EnergyPlus/PlantChillers.hh | 2 +- src/EnergyPlus/RoomAirModelUserTempPattern.cc | 4 +- src/EnergyPlus/RuntimeLanguageProcessor.cc | 20 ++++----- src/EnergyPlus/SetPointManager.cc | 18 ++++---- src/EnergyPlus/SystemReports.cc | 6 +-- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 4 +- tst/EnergyPlus/unit/WaterThermalTanks.unit.cc | 8 ++-- tst/EnergyPlus/unit/WeatherManager.unit.cc | 2 +- 18 files changed, 92 insertions(+), 92 deletions(-) diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc index 6eef10fab1d..4276c98e3e0 100644 --- a/src/EnergyPlus/CondenserLoopTowers.cc +++ b/src/EnergyPlus/CondenserLoopTowers.cc @@ -3563,9 +3563,9 @@ namespace CondenserLoopTowers { format("is inconsistent with Design Loop Delta Temperature specified in Sizing:Plant object = {}.", PlantSizData(PltSizCondNum).PlantLoopName)); ShowContinueError(state, format("..The Design Range Temperature specified in tower is = {:.2T}", this->DesRange)); - ShowContinueError(state, - format("..The Design Loop Delta Temperature specified in plant sizing data is = {:.2T}", - PlantSizData(PltSizCondNum).DeltaT)); + ShowContinueError( + state, + format("..The Design Loop Delta Temperature specified in plant sizing data is = {:.2T}", PlantSizData(PltSizCondNum).DeltaT)); } // check if the tower approach is different from plant sizing data DesTowerApproachFromPlant = PlantSizData(PltSizCondNum).ExitTemp - this->DesInletAirWBTemp; diff --git a/src/EnergyPlus/DaylightingDevices.cc b/src/EnergyPlus/DaylightingDevices.cc index 37a8942ad32..2766b34a142 100644 --- a/src/EnergyPlus/DaylightingDevices.cc +++ b/src/EnergyPlus/DaylightingDevices.cc @@ -159,7 +159,7 @@ namespace Dayltg { // sky is conveniently given by SurfAnisoSkyMult. NOTE: The solar shading code was modified to allow sunlit // fraction, sunlit area, SurfAnisoSkyMult, etc. to be calculated for attached shading surfaces. // Future shelf model improvements: - // 1. Allow beam and downgoing flux to pass the end of the inside shelf depending on actual shelf goemetry. + // 1. Allow beam and downgoing flux to pass the end of the inside shelf depending on actual shelf geometry. // 2. Reduce outside shelf view factor to sky (for daylighting) by taking into account anisotropic sky // distribution and shading, i.e. the daylighting equivalent of SurfAnisoSkyMult. // 3. Expand view factor to shelf calculation to handle more complicated geometry. @@ -1789,7 +1789,7 @@ namespace Dayltg { // DATE WRITTEN Dec 2011 // PURPOSE OF THIS SUBROUTINE: - // intialize zone gains at begin new environment + // initialize zone gains at begin new environment // SUBROUTINE LOCAL VARIABLE DECLARATIONS: diff --git a/src/EnergyPlus/EcoRoofManager.cc b/src/EnergyPlus/EcoRoofManager.cc index 845bea086de..a9376309da1 100644 --- a/src/EnergyPlus/EcoRoofManager.cc +++ b/src/EnergyPlus/EcoRoofManager.cc @@ -913,8 +913,8 @@ namespace EcoRoofManager { if (matER->calcMethod == Material::EcoRoofCalcMethod::Simple) { // THE SECTION BELOW WAS THE INITIAL MOISTURE DISTRIBUTION MODEL. - // Any line with "!-" was code. A line with "!" was just a comment. This is done in case this code needs to be resurrected in the future. - // See below this commented out code for the new moisture distribution model. + // Any line with "!-" was code. A line with "!" was just a comment. This is done in case this code needs to be resurrected in the + // future. See below this commented out code for the new moisture distribution model. //********************************************************************************************************* //********************************************************************************************************* // NEXT Redistribute moisture based on moisture diffusion. diff --git a/src/EnergyPlus/FuelCellElectricGenerator.cc b/src/EnergyPlus/FuelCellElectricGenerator.cc index c2a50442c7f..290c02633f4 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.cc +++ b/src/EnergyPlus/FuelCellElectricGenerator.cc @@ -1223,7 +1223,7 @@ namespace FuelCellElectricGenerator { SetupOutputVariable(state, "Generator Power Module Entering Air Enthalpy", Constant::Units::W, - this->Report.TotAirInEnthalphy, + this->Report.TotAirInEnthalpy, OutputProcessor::TimeStepType::System, OutputProcessor::StoreType::Average, this->Name); @@ -1804,7 +1804,7 @@ namespace FuelCellElectricGenerator { // units, NdotFuel in kmol/sec. Hmolfule in KJ/mol , // factor of 1000's to get to J/s or watts - this->FCPM.TotFuelInEnthalphy = Hmolfuel * 1000.0 * this->FCPM.NdotFuel * 1000.0; + this->FCPM.TotFuelInEnthalpy = Hmolfuel * 1000.0 * this->FCPM.NdotFuel * 1000.0; // Calculation Step 6, water compressor calculations @@ -1921,7 +1921,7 @@ namespace FuelCellElectricGenerator { // units, NdotAir in kmol/sec.; Hmolfuel in KJ/mol , // factor of 1000's to get to J/s or watts - this->FCPM.TotAirInEnthalphy = Hmolair * 1000.0 * this->FCPM.NdotAir * 1000.0; + this->FCPM.TotAirInEnthalpy = Hmolair * 1000.0 * this->FCPM.NdotAir * 1000.0; // calculation Step 8, Figure Product Gases @@ -2001,7 +2001,7 @@ namespace FuelCellElectricGenerator { // all the oxygen in the excess air stream this->FCPM.ConstitMolalFract(3) = Ndot02 / this->FCPM.NdotProdGas; - // all the H2O comming in plus the new H2O from reactions and the H2O from water used in reforming + // all the H2O coming in plus the new H2O from reactions and the H2O from water used in reforming this->FCPM.ConstitMolalFract(4) = NdotH2O / this->FCPM.NdotProdGas; // all the argon coming in. @@ -2013,9 +2013,9 @@ namespace FuelCellElectricGenerator { // units, NdotProdGas in kmol/sec.; HmolProdGases in KJ/mol , // factor of 1000's to get to J/s or watts - this->FCPM.TotProdGasEnthalphy = HmolProdGases * 1000.0 * this->FCPM.NdotProdGas * 1000.0; + this->FCPM.TotProdGasEnthalpy = HmolProdGases * 1000.0 * this->FCPM.NdotProdGas * 1000.0; - // calculation Step 9, Figure Skin lossess + // calculation Step 9, Figure Skin losses if (this->FCPM.SkinLossMode == DataGenerators::SkinLoss::ConstantRate) { // do nothing just use QdotSkin @@ -2054,15 +2054,15 @@ namespace FuelCellElectricGenerator { // calculation Step 13, Calculate Heat balance // move all terms in Equation 7 to RHS and calculate imbalance - Real64 MagofImbalance = -this->FCPM.TotFuelInEnthalphy - this->FCPM.TotAirInEnthalphy - this->FCPM.WaterInEnthalpy - + Real64 MagofImbalance = -this->FCPM.TotFuelInEnthalpy - this->FCPM.TotAirInEnthalpy - this->FCPM.WaterInEnthalpy - this->FCPM.DilutionAirInEnthalpy - this->FCPM.NdotFuel * state.dataGenerator->FuelSupply(this->FuelSupNum).LHV * 1000000.0 - - this->FCPM.PelancillariesAC + this->FCPM.Pel + this->FCPM.TotProdGasEnthalphy + this->FCPM.WaterOutEnthalpy + + this->FCPM.PelancillariesAC + this->FCPM.Pel + this->FCPM.TotProdGasEnthalpy + this->FCPM.WaterOutEnthalpy + this->FCPM.QdotStackCool + this->FCPM.QdotSkin + this->FCPM.DilutionAirOutEnthalpy; - // Now find a new total prod Gas Enthalphy that would result in an energy balance + // Now find a new total prod Gas Enthalpy that would result in an energy balance // TODO check signs... - Real64 tmpTotProdGasEnthalpy = this->FCPM.TotProdGasEnthalphy - MagofImbalance; + Real64 tmpTotProdGasEnthalpy = this->FCPM.TotProdGasEnthalpy - MagofImbalance; // solve for a new TprodGasLeavingFCPM using regula falsi method @@ -2339,7 +2339,7 @@ namespace FuelCellElectricGenerator { // loop through fuel constituents and sum up Cp - // two different themodynamic curve fits might be used + // two different thermodynamic curve fits might be used Real64 tempCp = 0.0; @@ -2905,7 +2905,7 @@ namespace FuelCellElectricGenerator { // AUTHOR Brent Griffith // DATE WRITTEN Aug 2005 - Real64 PelInput = Pel; // hold initial value of inout var + Real64 PelInput = Pel; // hold initial value of input var Real64 CurrentFractionalDay = double(state.dataGlobal->DayOfSim) + (int(state.dataGlobal->CurrentTime) + (state.dataHVACGlobal->SysTimeElapsed + @@ -3330,12 +3330,12 @@ namespace FuelCellElectricGenerator { this->FCPM.Eel = 0.0; this->FCPM.PelancillariesAC = 0.0; this->FCPM.NdotFuel = 0.0; - this->FCPM.TotFuelInEnthalphy = 0.0; + this->FCPM.TotFuelInEnthalpy = 0.0; this->FCPM.NdotProdGas = 0.0; this->FCPM.TprodGasLeavingFCPM = 0.0; - this->FCPM.TotProdGasEnthalphy = 0.0; + this->FCPM.TotProdGasEnthalpy = 0.0; this->FCPM.NdotAir = 0.0; - this->FCPM.TotAirInEnthalphy = 0.0; + this->FCPM.TotAirInEnthalpy = 0.0; this->FCPM.NdotLiqwater = 0.0; this->FCPM.TwaterInlet = 0.0; this->FCPM.WaterInEnthalpy = 0.0; @@ -3405,7 +3405,7 @@ namespace FuelCellElectricGenerator { this->ElecStorage.LastTimeStepStateOfCharge = this->ElecStorage.ThisTimeStepStateOfCharge; this->FCPM.PelLastTimeStep = this->FCPM.Pel; - // intialize flow rate in water loop, this is "requesting" flow + // initialize flow rate in water loop, this is "requesting" flow Real64 mdot = this->ExhaustHX.WaterMassFlowRateDesign; PlantUtilities::SetComponentFlowRate(state, mdot, this->ExhaustHX.WaterInNode, this->ExhaustHX.WaterOutNode, this->CWPlantLoc); @@ -3548,7 +3548,7 @@ namespace FuelCellElectricGenerator { this->Report.TairInlet = this->AirSup.TairIntoBlower; // State point 1 this->Report.TairIntoFCPM = this->AirSup.TairIntoFCPM; // State point 4 this->Report.NdotAir = this->FCPM.NdotAir; // air flow in kmol/sec - this->Report.TotAirInEnthalphy = this->FCPM.TotAirInEnthalphy; // State point 4 + this->Report.TotAirInEnthalpy = this->FCPM.TotAirInEnthalpy; // State point 4 this->Report.BlowerPower = this->AirSup.PairCompEl; // electrical power used by air supply blower this->Report.BlowerEnergy = this->AirSup.PairCompEl * state.dataHVACGlobal->TimeStepSysSec; // electrical energy this->Report.BlowerSkinLoss = this->AirSup.QskinLoss; // heat rate of losses by blower @@ -3556,7 +3556,7 @@ namespace FuelCellElectricGenerator { this->Report.TfuelInlet = state.dataGenerator->FuelSupply(this->FuelSupNum).TfuelIntoCompress; // State point 2 this->Report.TfuelIntoFCPM = state.dataGenerator->FuelSupply(this->FuelSupNum).TfuelIntoFCPM; // TEmperature state point 5 [C] this->Report.NdotFuel = this->FCPM.NdotFuel; // fuel flow in kmol/sec - this->Report.TotFuelInEnthalpy = this->FCPM.TotFuelInEnthalphy; // enthalpy at state point 5 [W] + this->Report.TotFuelInEnthalpy = this->FCPM.TotFuelInEnthalpy; // enthalpy at state point 5 [W] this->Report.FuelCompressPower = state.dataGenerator->FuelSupply(this->FuelSupNum).PfuelCompEl; // electrical power used by fuel supply compressor [W] this->Report.FuelCompressEnergy = @@ -3583,9 +3583,9 @@ namespace FuelCellElectricGenerator { this->Report.WaterPumpEnergy = this->WaterSup.PwaterCompEl * state.dataHVACGlobal->TimeStepSysSec; // electrical energy this->Report.WaterIntoFCPMEnthalpy = this->FCPM.WaterInEnthalpy; - this->Report.TprodGas = this->FCPM.TprodGasLeavingFCPM; // temperature at State point 7 - this->Report.EnthalProdGas = this->FCPM.TotProdGasEnthalphy; // enthalpy at State point 7 - this->Report.NdotProdGas = this->FCPM.NdotProdGas; // flow rate at point 7 [kmol/sec] + this->Report.TprodGas = this->FCPM.TprodGasLeavingFCPM; // temperature at State point 7 + this->Report.EnthalProdGas = this->FCPM.TotProdGasEnthalpy; // enthalpy at State point 7 + this->Report.NdotProdGas = this->FCPM.NdotProdGas; // flow rate at point 7 [kmol/sec] this->Report.NdotProdAr = this->FCPM.ConstitMolalFract(5) * this->FCPM.NdotProdGas; this->Report.NdotProdCO2 = this->FCPM.ConstitMolalFract(1) * this->FCPM.NdotProdGas; this->Report.NdotProdH2O = this->FCPM.ConstitMolalFract(4) * this->FCPM.NdotProdGas; diff --git a/src/EnergyPlus/HybridEvapCoolingModel.hh b/src/EnergyPlus/HybridEvapCoolingModel.hh index c4309a2eea7..7cd7a388fe8 100644 --- a/src/EnergyPlus/HybridEvapCoolingModel.hh +++ b/src/EnergyPlus/HybridEvapCoolingModel.hh @@ -288,12 +288,12 @@ namespace HybridEvapCoolingModel { Real64 QLatentZoneOut; // W Real64 QLatentZoneOutMass; // kg/s Real64 ExternalStaticPressure; // - Real64 RequestedHumdificationMass; - Real64 RequestedHumdificationLoad; - Real64 RequestedHumdificationEnergy; - Real64 RequestedDeHumdificationMass; - Real64 RequestedDeHumdificationLoad; - Real64 RequestedDeHumdificationEnergy; + Real64 RequestedHumidificationMass; + Real64 RequestedHumidificationLoad; + Real64 RequestedHumidificationEnergy; + Real64 RequestedDeHumidificationMass; + Real64 RequestedDeHumidificationLoad; + Real64 RequestedDeHumidificationEnergy; Real64 RequestedLoadToHeatingSetpoint; Real64 RequestedLoadToCoolingSetpoint; int TsaMin_schedule_pointer; diff --git a/src/EnergyPlus/IceThermalStorage.cc b/src/EnergyPlus/IceThermalStorage.cc index a6d19af28d0..a3fe36592f7 100644 --- a/src/EnergyPlus/IceThermalStorage.cc +++ b/src/EnergyPlus/IceThermalStorage.cc @@ -1525,7 +1525,7 @@ namespace IceThermalStorage { // There are three possible to calculate QiceMax // with ChillerCapacity(Chiller+ITS), ITS capacity(ITS), and QchillerMax(Chiller). //-------------------------------------------------------- - // Calcualte QiceMax with QiceMaxByChiller, QiceMaxByITS, QchillerMax + // Calculate QiceMax with QiceMaxByChiller, QiceMaxByITS, QchillerMax //-------------------------------------------------------- // Calculate Qice charge max by Chiller with Twb and UAIceCh Real64 QiceMaxByChiller; @@ -1562,7 +1562,7 @@ namespace IceThermalStorage { } // Check Uact for Discharging Process //-------------------------------------------------------- - // Calcualte possible ITSChargingRate with Uact, Then error check + // Calculate possible ITSChargingRate with Uact, Then error check //-------------------------------------------------------- // Calculate possible ITSChargingRate with Uact Real64 Qice = Uact * this->ITSNomCap / TimeInterval; //[W] @@ -1617,7 +1617,7 @@ namespace IceThermalStorage { // Qice is maximized when ChillerInletTemp and ChillerOutletTemp(input data) is almost same due to LMTD method. // Qice is minimized(=0) when ChillerInletTemp is almost same as FreezTemp(=0). - // Initilize + // Initialize Real64 Tfr = FreezTempIP; Real64 ChOutletTemp = TempSItoIP(chillerOutletTemp); //[degF] = ConvertSItoIP[degC] // Chiller outlet temp must be below freeze temp, or else no charge @@ -1710,7 +1710,7 @@ namespace IceThermalStorage { // Qice is calculate input U which is within boundary between Umin and Umax. Real64 Qice = Uact * this->ITSNomCap / TimeInterval; - // Qice cannot exceed MaxCap calulated by CalcIceStorageCapacity + // Qice cannot exceed MaxCap calculated by CalcIceStorageCapacity // Note Qice is negative here, MaxCap is positive Qice = max(Qice, -MaxCap); diff --git a/src/EnergyPlus/InputProcessing/InputProcessor.cc b/src/EnergyPlus/InputProcessing/InputProcessor.cc index b66d70f7d01..335639321f3 100644 --- a/src/EnergyPlus/InputProcessing/InputProcessor.cc +++ b/src/EnergyPlus/InputProcessing/InputProcessor.cc @@ -648,7 +648,7 @@ std::string InputProcessor::getAlphaFieldValue(json const &ep_object, json const Real64 InputProcessor::getRealFieldValue(json const &ep_object, json const &schema_obj_props, std::string const &fieldName) { // Return the value of fieldName in ep_object as a Real64. - // If the field value is a string, then assum autosize and return Constant::AutoCalculate(-99999). + // If the field value is a string, then assume autosize and return Constant::AutoCalculate(-99999). // If the field is not present in ep_object then return its default if there is one, or return 0.0 auto it = ep_object.find(fieldName); if (it != ep_object.end()) { @@ -681,7 +681,7 @@ Real64 InputProcessor::getRealFieldValue(json const &ep_object, json const &sche int InputProcessor::getIntFieldValue(json const &ep_object, json const &schema_obj_props, std::string const &fieldName) { // Return the value of fieldName in ep_object as an integer. - // If the field value is a string, then assume autosize or autocalulate and return Constant::AutoCalculate(-99999). + // If the field value is a string, then assume autosize or autocalculate and return Constant::AutoCalculate(-99999). // If the field is not present in ep_object then return its default if there is one, or return 0 auto const &schema_field_obj = schema_obj_props[fieldName]; @@ -1473,7 +1473,7 @@ void InputProcessor::reportIDFRecordsStats(EnergyPlusData &state) state.dataOutput->iNumberOfDefaultedFields = 0; // Number of defaulted fields in IDF state.dataOutput->iTotalFieldsWithDefaults = 0; // Total number of fields that could be defaulted state.dataOutput->iNumberOfAutoSizedFields = 0; // Number of autosized fields in IDF - state.dataOutput->iTotalAutoSizableFields = 0; // Total number of autosizeable fields + state.dataOutput->iTotalAutoSizableFields = 0; // Total number of autosizable fields state.dataOutput->iNumberOfAutoCalcedFields = 0; // Number of autocalculated fields state.dataOutput->iTotalAutoCalculatableFields = 0; // Total number of autocalculatable fields @@ -1710,7 +1710,7 @@ void InputProcessor::preProcessorCheck(EnergyPlusData &state, bool &PreP_Fatal) // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // This routine checks for existance of "Preprocessor Message" object and + // This routine checks for existence of "Preprocessor Message" object and // performs appropriate action. // METHODOLOGY EMPLOYED: diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc index d10119a85d4..cf00368d7b0 100644 --- a/src/EnergyPlus/MixedAir.cc +++ b/src/EnergyPlus/MixedAir.cc @@ -431,7 +431,7 @@ void SimOAComponent(EnergyPlusData &state, bool const FirstHVACIteration, int &CompIndex, int const AirLoopNum, // air loop index for economizer lockout coordination - bool const Sim, // if TRUE, simulate component; if FALSE, just set the coil exisitence flags + bool const Sim, // if TRUE, simulate component; if FALSE, just set the coil existence flags int const OASysNum, // index to outside air system bool &OAHeatingCoil, // TRUE indicates a heating coil has been found bool &OACoolingCoil, // TRUE indicates a cooling coil has been found @@ -1238,7 +1238,7 @@ void GetOAControllerInputs(EnergyPlusData &state) ErrorsFound); // add applicable faults identifier to avoid string comparison at each time step - // loop through each fault for each OA controller and determine economizer faultys + // loop through each fault for each OA controller and determine economizer faults for (int i = 1; i <= state.dataFaultsMgr->NumFaultyEconomizer; ++i) { if (state.dataFaultsMgr->FaultsEconomizer(i).ControllerTypeEnum != iController_AirEconomizer) continue; if (Util::SameString(state.dataMixedAir->OAController(OutAirNum).Name, state.dataFaultsMgr->FaultsEconomizer(i).ControllerName)) { @@ -3127,7 +3127,7 @@ void InitOAController(EnergyPlusData &state, int const OAControllerNum, bool con vent_mech.TotPeopleOAFlow = TotalPeopleOAFlow; } } else { - // Stand Alone ERV does not require a termperature setpoint schedule, make setpoint equal to lower economizer limit + // Stand Alone ERV does not require a temperature setpoint schedule, make setpoint equal to lower economizer limit thisOAController.MixSetTemp = thisOAController.TempLowLim; } } @@ -3365,7 +3365,7 @@ void OAControllerProps::CalcOAController(EnergyPlusData &state, int const AirLoo this->HeatRecoveryBypassStatus = 0; // HR bypass status for reporting this->HRHeatingCoilActive = 0; // resets report variable this->MixedAirTempAtMinOAFlow = state.dataLoopNodes->Node(this->RetNode).Temp; // track return T - this->HighHumCtrlStatus = 0; // high humdity control status for reporting + this->HighHumCtrlStatus = 0; // high humidity control status for reporting this->OAFractionRpt = 0.0; // actual OA fraction for reporting this->EconoActive = false; // DataAirLoop variable (OA Controllers) @@ -3665,7 +3665,7 @@ Real64 VentilationMechanicalProps::CalcMechVentController(EnergyPlusData &state, Real64 SysEv; // System ventilation efficiency Real64 NodeTemp; // node temperature Real64 NodeHumRat; // node humidity ratio - Real64 ZoneMaxCO2 = 0.0; // Breathing-zone CO2 concentartion + Real64 ZoneMaxCO2 = 0.0; // Breathing-zone CO2 concentration Real64 ZoneMinCO2 = 0.0; // Minimum CO2 concentration in zone Real64 ZoneOAMin = 0.0; // Minimum Zone OA flow rate when the zone is unoccupied (i.e. ZoneOAPeople = 0) Real64 ZoneOAMax = 0.0; // Maximum Zone OA flow rate (ZoneOAPeople + ZoneOACalc[static_cast(DataSizing::OAFlowCalcMethod::PerArea)]) @@ -4444,7 +4444,7 @@ void OAControllerProps::CalcOAEconomizer(EnergyPlusData &state, } else { - // simulate OA System if equipment exists other than the mixer (e.g., heating/cooling coil, HX, ect.) + // simulate OA System if equipment exists other than the mixer (e.g., heating/cooling coil, HX, etc.) // 1 - check min OA flow result if (this->FixedMin) { @@ -4637,7 +4637,7 @@ void OAMixerProps::CalcOAMixer(EnergyPlusData &state) // Define a recirculation mass flow rate Real64 RecircMassFlowRate = this->RetMassFlowRate - this->RelMassFlowRate; // In certain low flow conditions the return air mass flow rate can be below the outside air value established - // by the user. This check will ensure that this condition does not result in unphysical air properties. + // by the user. This check will ensure that this condition does not result in non-physical air properties. if (RecircMassFlowRate < 0.0) { RecircMassFlowRate = 0.0; this->RelMassFlowRate = this->RetMassFlowRate; @@ -5340,7 +5340,7 @@ bool CheckForControllerWaterCoil(EnergyPlusData &state, // DATE WRITTEN May 2009 // PURPOSE OF THIS FUNCTION: - // This routine checks the controller list for existance of the reference coil. + // This routine checks the controller list for existence of the reference coil. if (state.dataMixedAir->GetOASysInputFlag) { GetOutsideAirSysInputs(state); diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index 0bcfee8c6d0..808ff36c829 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -844,7 +844,7 @@ namespace OutdoorAirUnit { break; } case CompType::Desiccant: { - // Futher Enhancement + // Future Enhancement // CASE('DEHUMIDIFIER:DESICCANT:SYSTEM') // thisOutAirUnit%OAEquip(CompNum)%Type= CompType::Desiccant break; @@ -1404,7 +1404,7 @@ namespace OutdoorAirUnit { // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: - // This subroutine is for sizing zoen outdoor air control unit components for which flow rates have not been + // This subroutine is for sizing zone outdoor air control unit components for which flow rates have not been // specified in the input. // METHODOLOGY EMPLOYED: @@ -1625,14 +1625,14 @@ namespace OutdoorAirUnit { Real64 SetPointTemp; // temperature that will be used to control the radiant system [Celsius] Real64 HiCtrlTemp; // Current high point in setpoint temperature range Real64 LoCtrlTemp; // Current low point in setpoint temperature range - Real64 AirInEnt; // RE-calcualte the Enthalpy of supply air + Real64 AirInEnt; // RE-calculate the Enthalpy of supply air Real64 AirOutletTemp = 0.0; Real64 ZoneSupAirEnt; // Specific humidity ratio of inlet air (kg moisture / kg moist air) // Latent output Real64 LatentOutput; // Latent (moisture) add/removal rate, negative is dehumidification [kg/s] Real64 SpecHumOut; // Specific humidity ratio of outlet air (kg moisture / kg moist air) Real64 SpecHumIn; // Specific humidity ratio of inlet air (kg moisture / kg moist air) - Real64 ZoneAirEnt; // zone air enthalphy J/kg + Real64 ZoneAirEnt; // zone air enthalpy J/kg // initialize local variables int const InletNode = thisOutAirUnit.AirInletNode; // Unit air inlet node, only used if ExtFan diff --git a/src/EnergyPlus/Plant/EquipAndOperations.cc b/src/EnergyPlus/Plant/EquipAndOperations.cc index 96d2871e845..67f9907c366 100644 --- a/src/EnergyPlus/Plant/EquipAndOperations.cc +++ b/src/EnergyPlus/Plant/EquipAndOperations.cc @@ -248,7 +248,7 @@ namespace DataPlant { int numHXsOnSupervisedLoops = 0; for (int LoopNum = 1; LoopNum <= state.dataPlnt->TotNumLoops; ++LoopNum) { if (this->PlantLoopIndicesBeingSupervised(LoopNum) > 0) { - // search for any Heat axchangers on loop supply side + // search for any Heat exchangers on loop supply side auto &this_plant_loopside(state.dataPlnt->PlantLoop(LoopNum).LoopSide(DataPlant::LoopSideLocation::Supply)); for (int BranchNum = 1; BranchNum <= this_plant_loopside.TotalBranches; ++BranchNum) { for (int CompNum = 1; CompNum <= this_plant_loopside.Branch(BranchNum).TotalComponents; ++CompNum) { @@ -1423,12 +1423,12 @@ namespace DataPlant { } // step 4. check that there is sufficient flow in source side for chosen leader to avoid runaway plant conditions on source side - // if not, see if other side could run benefically as leader and switch to it if so + // if not, see if other side could run beneficially as leader and switch to it if so // Real64 FlowImbalanceRatioThreshold = 10.0; // TODO, check with TRANE engineering about WWHP operating limits wrt to relative flows (real // // systems have a pumped sided arm flow situation and do not have low flow problems) // if (CoolLedNeed) { - // if (CW_RetMdot / HW_RetMdot > FlowImbalanceRatioThreshold) { // insuficient flow in source side relative to load side + // if (CW_RetMdot / HW_RetMdot > FlowImbalanceRatioThreshold) { // insufficient flow in source side relative to load side // CoolLedNeed = false; // // if (HW_Qdot > 1.0) { // // HeatLedNeed = true; @@ -1436,7 +1436,7 @@ namespace DataPlant { // } //} // if (HeatLedNeed) { - // if (HW_RetMdot / CW_RetMdot > FlowImbalanceRatioThreshold) { // insuficient flow in source side relative to load side + // if (HW_RetMdot / CW_RetMdot > FlowImbalanceRatioThreshold) { // insufficient flow in source side relative to load side // HeatLedNeed = false; // // if (CW_Qdot < -1.0) { // // CoolLedNeed = true; @@ -1549,11 +1549,11 @@ namespace DataPlant { void ChillerHeaterSupervisoryOperationData::ProcessAndSetAuxilBoiler(EnergyPlusData &state) { // Check for boiler used as auxiliary or supplemental - // Assume boilers are in-line on supply side outlet branch, typically on secodary loop but may be on primary loop + // Assume boilers are in-line on supply side outlet branch, typically on secondary loop but may be on primary loop this->Report.BoilerAux_OpMode = 0; if (this->PlantOps.numBoilers <= 0) return; - // first intialize them to be off + // first initialize them to be off if (this->PlantOps.numBoilers > 0) { for (int BoilerNum = 1; BoilerNum <= this->PlantOps.numBoilers; ++BoilerNum) { state.dataPlnt->PlantLoop(this->PlantBoilerComps(BoilerNum).loopNum) diff --git a/src/EnergyPlus/PlantChillers.hh b/src/EnergyPlus/PlantChillers.hh index a67380b0711..c61f0c4df2a 100644 --- a/src/EnergyPlus/PlantChillers.hh +++ b/src/EnergyPlus/PlantChillers.hh @@ -207,7 +207,7 @@ namespace PlantChillers { int HeatRecInletLimitSchedNum; // index for schedule for the inlet high limit for heat recovery operation PlantLocation HRPlantLoc; // heat recovery water plant loop component index std::string EndUseSubcategory; // identifier use for the end use subcategory - Real64 CondOutletHumRat; // kg/kg - condenser outlet humditiy ratio, air side + Real64 CondOutletHumRat; // kg/kg - condenser outlet humidity ratio, air side Real64 ActualCOP; Real64 QHeatRecovery; Real64 EnergyHeatRecovery; diff --git a/src/EnergyPlus/RoomAirModelUserTempPattern.cc b/src/EnergyPlus/RoomAirModelUserTempPattern.cc index 6a0738ea74e..7217e1e9778 100644 --- a/src/EnergyPlus/RoomAirModelUserTempPattern.cc +++ b/src/EnergyPlus/RoomAirModelUserTempPattern.cc @@ -170,7 +170,7 @@ void GetSurfHBDataForTempDistModel(EnergyPlusData &state, int const ZoneNum) // auto &patternZoneInfo = state.dataRoomAir->AirPatternZoneInfo(ZoneNum); auto const &zoneHeatBal = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum); - // intialize in preperation for calculations + // initialize in preparation for calculations patternZoneInfo.Tstat = zoneHeatBal.MAT; patternZoneInfo.Tleaving = zoneHeatBal.MAT; patternZoneInfo.Texhaust = zoneHeatBal.MAT; @@ -733,7 +733,7 @@ void SetSurfHBDataForTempDistModel(EnergyPlusData &state, int const ZoneNum) // Real64 H2OHtOfVap = PsyHgAirFnWTdb(zoneNode.HumRat, returnNode.Temp); - // Include impact of under case returns for refrigerated display cases when updateing return node + // Include impact of under case returns for refrigerated display cases when updating return node // humidity ratio if (!zone.NoHeatToReturnAir) { if (MassFlowRA > 0) { diff --git a/src/EnergyPlus/RuntimeLanguageProcessor.cc b/src/EnergyPlus/RuntimeLanguageProcessor.cc index 55dc9cd6380..361d19b5b4f 100644 --- a/src/EnergyPlus/RuntimeLanguageProcessor.cc +++ b/src/EnergyPlus/RuntimeLanguageProcessor.cc @@ -213,7 +213,7 @@ void InitializeRuntimeLanguage(EnergyPlusData &state) state.dataRuntimeLang->ErlVariable(state.dataRuntimeLangProcessor->CurrentTimeVariableNum).Value = SetErlValueNumber(tmpCurrentTime); tmpMinutes = ((tmpCurrentTime - double(state.dataGlobal->HourOfDay - 1)) * 60.0); // -1.0 // off by 1 state.dataRuntimeLang->ErlVariable(state.dataRuntimeLangProcessor->MinuteVariableNum).Value = SetErlValueNumber(tmpMinutes); - // Subtract 7 from HolidayIndex to maintain compatability for EMS where 1=Holiday,2=SummerDesignDay, 3=WinterDesignDay, 4=CustomDay1, + // Subtract 7 from HolidayIndex to maintain compatibility for EMS where 1=Holiday,2=SummerDesignDay, 3=WinterDesignDay, 4=CustomDay1, // 5=CustomDay2, but not <0 if (state.dataEnvrn->HolidayIndex == 0) { state.dataRuntimeLang->ErlVariable(state.dataRuntimeLangProcessor->HolidayVariableNum).Value = SetErlValueNumber(0.0); @@ -248,7 +248,7 @@ void BeginEnvrnInitializeRuntimeLanguage(EnergyPlusData &state) // SUBROUTINE INFORMATION: // AUTHOR B. Griffith // DATE WRITTEN March 2010 - // MODIFIED B. Griffith, added Sensor initialation + // MODIFIED B. Griffith, added Sensor initialization // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: @@ -344,7 +344,7 @@ void BeginEnvrnInitializeRuntimeLanguage(EnergyPlusData &state) state.dataRuntimeLang->TrendVariable(TrendVarNum).TrendValARR({1, TrendDepth}) = 0.0; } - // reinitilize sensors + // reinitialize sensors for (SensorNum = 1; SensorNum <= state.dataRuntimeLang->NumSensors; ++SensorNum) { SetInternalVariableValue( state, state.dataRuntimeLang->Sensor(SensorNum).VariableType, state.dataRuntimeLang->Sensor(SensorNum).Index, 0.0, 0); @@ -599,7 +599,7 @@ void ParseStack(EnergyPlusData &state, int const StackNum) } if (!ReadyForEndif(NestedIfDepth)) { - AddError(state, StackNum, LineNum, "ENDIF statement without corresponding IF stetement."); + AddError(state, StackNum, LineNum, "ENDIF statement without corresponding IF statement."); } ReadyForEndif(NestedIfDepth) = false; ReadyForElse(NestedIfDepth) = false; @@ -944,7 +944,7 @@ void WriteTrace(EnergyPlusData &state, int const StackNum, int const Instruction // AUTHOR Peter Graham Ellis // DATE WRITTEN June 2006 // MODIFIED Brent Griffith, May 2009 - // Brent Griffith, May 2016, added bool and fatal error messages for runtime problems with math and unitialized vars + // Brent Griffith, May 2016, added bool and fatal error messages for runtime problems with math and uninitiated vars // RE-ENGINEERED na // PURPOSE OF THIS SUBROUTINE: @@ -1244,7 +1244,7 @@ void ParseExpression(EnergyPlusData &state, ++NumErrors; DivFound = false; } else if (OperatorProcessing && (NextChar == '-')) { - // if operator was deterined last pass and this character is a -, then insert a 0 before the minus and treat as subtraction + // if operator was determined last pass and this character is a -, then insert a 0 before the minus and treat as subtraction // example: change "Var == -1" to "Var == 0-1" OperatorProcessing = false; String.insert(Pos, "0"); @@ -1285,7 +1285,7 @@ void ParseExpression(EnergyPlusData &state, std::string const cc(String.substr(Pos, 2)); if (parse("==", ErlFunc::Equal, false) || parse("<>", ErlFunc::NotEqual, false) || parse("<=", ErlFunc::LessOrEqual, false) || parse(">=", ErlFunc::GreaterOrEqual, false) || parse("||", ErlFunc::LogicalOR, false) || parse("&&", ErlFunc::LogicalAND, false)) { - // One of the comparision / logical operators + // One of the comparison / logical operators OperatorProcessing = true; } else if (String[Pos] == '@') { // next check for builtin functions signaled by "@" @@ -1613,7 +1613,7 @@ int ProcessTokens( state.dataRuntimeLang->ErlExpression(ExpressionNum).NumOperands = NumOperands; state.dataRuntimeLang->ErlExpression(ExpressionNum).Operand.allocate(NumOperands); - // PE commment: Need a right-hand and left-hand check for these, not just number of operators + // PE comment: Need a right-hand and left-hand check for these, not just number of operators // Unification of TYPEs would turn these into one-liners state.dataRuntimeLang->ErlExpression(ExpressionNum).Operand(1).Type = static_cast(static_cast(Token(Pos - 1).Type)); @@ -3749,7 +3749,7 @@ ErlValueType StringValue(std::string const &String) { // FUNCTION INFORMATION: // AUTHOR P. Ellis - // DATE WRITTEN unkown + // DATE WRITTEN unknown // MODIFIED na // RE-ENGINEERED na @@ -3936,7 +3936,7 @@ int NewEMSVariable(EnergyPlusData &state, std::string const &VariableName, int c void ExternalInterfaceSetErlVariable(EnergyPlusData &state, int const varNum, // The variable index to be written during run time - Real64 const value // The real time value of the vairable to be set + Real64 const value // The real time value of the variable to be set ) { diff --git a/src/EnergyPlus/SetPointManager.cc b/src/EnergyPlus/SetPointManager.cc index 3a186e22279..b0e93ac5492 100644 --- a/src/EnergyPlus/SetPointManager.cc +++ b/src/EnergyPlus/SetPointManager.cc @@ -1610,7 +1610,7 @@ void InitSetPointManagers(EnergyPlusData &state) // SetpointManager:MultiZone:Humidity:Minimum // SetpointManager:MultiZone:Humidity:Maximum // Sep 2010 B.A. Nigusse, FSEC/UCF - // Added control varibles for SetpointManage:Scheduled + // Added control variables for SetpointManage:Scheduled // Jan 2022 Wooyoung Jung, Jeremy Lerond and Jian Zhang, PNNL // Added new setpoint managers: // SetpointManager:SystemNodeReset:Temperature @@ -3261,8 +3261,8 @@ void SPMReturnAirBypassFlow::calculate(EnergyPlusData &state) // DATE WRITTEN July 2005 // PURPOSE OF THIS SUBROUTINE: - // Given the desired setpoint temperature, calulate the flow rate through the - // return asir branch that will deliver the desired temperature at the loop outlet + // Given the desired setpoint temperature, calculate the flow rate through the + // return air branch that will deliver the desired temperature at the loop outlet // node. auto &mixerRABInNode = state.dataLoopNodes->Node(this->rabMixInNodeNum); @@ -3458,7 +3458,7 @@ void SPMFollowOutsideAirTemp::calculate(EnergyPlusData &state) // Set the setpoint based on outdoor air dry-bulb/wet-bulb temperature // METHODOLOGY EMPLOYED: - // Based on reference temperature type specifed in the setpoint manager, + // Based on reference temperature type specified in the setpoint manager, // the setpoint is calculated as OutWetBulbTemp(Or OutDryBulbTemp) + Offset. // The sign convention is that a positive Offset will increase the resulting setpoint. // Final value of the setpoint is limited by the Max and Min limit specified in the setpoint manager. @@ -3482,7 +3482,7 @@ void SPMFollowSysNodeTemp::calculate(EnergyPlusData &state) // to generate setpoint on a second system node. If the reference node is also designated // to be an outdoor air (intake) node, then this setpoint manager can be used to follow // outdoor air conditions that are adjusted for altitude. - // Also, based on reference temperature type specifed in the setpoint manager, the out door air wet-bulb + // Also, based on reference temperature type specified in the setpoint manager, the out door air wet-bulb // or dry-bulb temperature at the reference node could be used. // A temperature offset will be applied to the value obtained from the reference system node. // If this value is zero, and the limits are met, then the resulting setpoint will be exactly the same @@ -3510,7 +3510,7 @@ void SPMFollowGroundTemp::calculate(EnergyPlusData &state) // Set the setpoint based on current ground temperature // METHODOLOGY EMPLOYED: - // Based on reference ground temperature object type specifed in the setpoint manager, + // Based on reference ground temperature object type specified in the setpoint manager, // the setpoint is calculated as GroundTemperature + Offset. // The sign convention is that a positive Offset will increase the resulting setpoint. // Final value of the setpoint is limited by the Max and Min limit specified in the setpoint manager. @@ -3669,7 +3669,7 @@ void SPMCondenserEnteringTemp::calculate(EnergyPlusData &state) SetPoint = dspm->CET_DesignEnteringCondenserTemp + 1.0; } else if ((state.dataEnvrn->OutWetBulbTemp >= dspm->CET_MinActualWetBulbTemp) && (this->towerDesignInletAirWetBulbTemp >= dspm->CET_DesignMinWetBulbTemp) && (dspm->CET_CurMinLift > this->minLift)) { - // Boundaries are satified; use optimized condenser entering water temp + // Boundaries are satisfied; use optimized condenser entering water temp SetPoint = dspm->CET_OptCondenserEnteringTemp; } else { // Boundaries violated; Reset to scheduled value of condenser water entering setpoint @@ -3905,7 +3905,7 @@ void SPMReturnWaterTemp::calculate(EnergyPlusData &state) "The manager is specified to look to the return node setpoint to find a target return temperature, but the node " "setpoint was invalid"); ShowContinueError(state, - format("Verify that a separate sepoint manager is specified to set the setpoint on the return node named \"{}\"", + format("Verify that a separate setpoint manager is specified to set the setpoint on the return node named \"{}\"", state.dataLoopNodes->NodeID(this->returnNodeNum))); ShowContinueError(state, "Or change the target return temperature input type to constant or scheduled"); ShowFatalError(state, "Missing reference setpoint"); @@ -4370,7 +4370,7 @@ void ResetHumidityRatioCtrlVarType(EnergyPlusData &state, int const NodeNum) // DATE WRITTEN August 2015 // PURPOSE OF THIS SUBROUTINE: - // Resets setpoint control variable type to "Maximum Humidty Ratio" if control variable type + // Resets setpoint control variable type to "Maximum Humidity Ratio" if control variable type // is "Humidity Ratio". // METHODOLOGY EMPLOYED: diff --git a/src/EnergyPlus/SystemReports.cc b/src/EnergyPlus/SystemReports.cc index ebf30aae9bb..15467af6512 100644 --- a/src/EnergyPlus/SystemReports.cc +++ b/src/EnergyPlus/SystemReports.cc @@ -3829,7 +3829,7 @@ void ReportVentilationLoads(EnergyPlusData &state) if (!thisZoneEquipConfig.IsControlled) continue; Real64 ZAirSysZoneVentLoad = 0.0; // ventilation load attributed to a particular zone from all primary air systems serving the zone [J] - Real64 ZAirSysOutAirFlow = 0.0; // outside air flow rate for zone from all primary air systems serving thezone [kg/s] + Real64 ZAirSysOutAirFlow = 0.0; // outside air flow rate for zone from all primary air systems serving the zone [kg/s] Real64 ZFAUFlowRate = 0.0; // Zone forced Air unit air mass flow rate [kg/s] Real64 ZFAUZoneVentLoad = 0.0; // ventilation load attributed to a particular zone from zone forced air units [J] Real64 ZFAUOutAirFlow = 0.0; // outside air flow rate for zone from zone forced air units. [kg/s] @@ -4138,7 +4138,7 @@ void ReportVentilationLoads(EnergyPlusData &state) AirSysZoneVentLoad = 0.0; AirSysOutAirFlow = 0.0; } else { - // Calculate return and mixed air ethalpies + // Calculate return and mixed air enthalpies AirSysEnthReturnAir = Psychrometrics::PsyHFnTdbW(Node(ReturnAirNode).Temp, Node(ReturnAirNode).HumRat); AirSysEnthMixedAir = Psychrometrics::PsyHFnTdbW(Node(MixedAirNode).Temp, Node(MixedAirNode).HumRat); @@ -4473,7 +4473,7 @@ void FindDemandSideMatch(EnergyPlusData &state, // DATE WRITTEN September 2004 // PURPOSE OF THIS SUBROUTINE: - // This subroutine intializes the connections between various loops. + // This subroutine initializes the connections between various loops. // Due to the fact that this requires numerous string compares, it // is much more efficient to find this information once and then // store it in module level variables (LoopConnect derived type). diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index dd552559557..9483baea27f 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -21297,7 +21297,7 @@ ScheduleTypeLimits, percent; !- Unit Type Schedule:Constant, - Schedule_Constant_Humdifier, !- Name + Schedule_Constant_Humidifier, !- Name Percent, !- Schedule Type Limits Name 0; !- Hourly Value @@ -21324,7 +21324,7 @@ Schedule:Constant, state->dataZoneCtrls->HumidityControlZone(1).ControlName = "East Zone"; state->dataZoneCtrls->HumidityControlZone(1).ZoneName = "East Zone"; state->dataZoneCtrls->HumidityControlZone(1).ActualZoneNum = 1; - state->dataZoneCtrls->HumidityControlZone(1).HumidifyingSchedIndex = ScheduleManager::GetScheduleIndex(*state, "Schedule_Constant_Humdifier"); + state->dataZoneCtrls->HumidityControlZone(1).HumidifyingSchedIndex = ScheduleManager::GetScheduleIndex(*state, "Schedule_Constant_Humidifier"); state->dataZoneCtrls->HumidityControlZone(1).DehumidifyingSchedIndex = ScheduleManager::GetScheduleIndex(*state, "Schedule_Constant_Dehumidifier"); diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc index dcc74d48ce4..2e72c901938 100644 --- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc +++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc @@ -2395,7 +2395,7 @@ TEST_F(EnergyPlusFixture, DesuperheaterTimeAdvanceCheck) WaterThermalTanks::WaterThermalTankData &Tank = state->dataWaterThermalTanks->WaterThermalTank(TankNum); WaterThermalTanks::WaterHeaterDesuperheaterData &Desuperheater = state->dataWaterThermalTanks->WaterHeaterDesuperheater(Tank.DesuperheaterNum); - // Inititate tank conditions + // Initialize tank conditions state->dataGlobal->HourOfDay = 0; state->dataGlobal->TimeStep = 1; state->dataGlobal->TimeStepZone = 1; @@ -2762,7 +2762,7 @@ TEST_F(EnergyPlusFixture, StratifiedTank_GSHP_DesuperheaterSourceHeat) EXPECT_EQ(Desuperheater.DXSysPLR, 0.8); // The heater rate is correctly calculated EXPECT_EQ(Desuperheater.HeaterRate, 1000 * 0.25 / Desuperheater.DXSysPLR * Desuperheater.DesuperheaterPLR); - // The source rate calculated in stratified tank calculation function is near the heater rate calcualted in desuperheater function + // The source rate calculated in stratified tank calculation function is near the heater rate calculated in desuperheater function EXPECT_NEAR(Tank.SourceRate, Desuperheater.HeaterRate, Tank.SourceRate * 0.05); } @@ -3087,7 +3087,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_Multispeed_Coil_Test) // Calculate multispeed DX cooling coils DXCoils::CalcMultiSpeedDXCoilCooling(*state, DXNum, 1, 1, 2, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 1); - // Source availably heat successfully passed to DataHeatBalance::HeatReclaimDXCoil data struct + // Source available heat successfully passed to DataHeatBalance::HeatReclaimDXCoil data struct EXPECT_EQ(state->dataHeatBal->HeatReclaimDXCoil(DXNum).AvailCapacity, state->dataDXCoils->DXCoil(DXNum).TotalCoolingEnergyRate + state->dataDXCoils->DXCoil(DXNum).ElecCoolingPower); @@ -3095,7 +3095,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_Multispeed_Coil_Test) WaterThermalTanks::WaterThermalTankData &Tank = state->dataWaterThermalTanks->WaterThermalTank(TankNum); WaterThermalTanks::WaterHeaterDesuperheaterData &Desuperheater = state->dataWaterThermalTanks->WaterHeaterDesuperheater(Tank.DesuperheaterNum); - // Inititate tank conditions + // Initialize tank conditions state->dataGlobal->HourOfDay = 0; state->dataGlobal->TimeStep = 1; state->dataGlobal->TimeStepZone = 1; diff --git a/tst/EnergyPlus/unit/WeatherManager.unit.cc b/tst/EnergyPlus/unit/WeatherManager.unit.cc index bbdcd682397..735dc16f49e 100644 --- a/tst/EnergyPlus/unit/WeatherManager.unit.cc +++ b/tst/EnergyPlus/unit/WeatherManager.unit.cc @@ -816,7 +816,7 @@ TEST_F(EnergyPlusFixture, WeatherManager_NoLocation) } // Test for https://github.com/NREL/EnergyPlus/issues/7550 -TEST_F(SQLiteFixture, DesignDay_EnthalphyAtMaxDB) +TEST_F(SQLiteFixture, DesignDay_EnthalpyAtMaxDB) { state->dataSQLiteProcedures->sqlite->createSQLiteSimulationsRecord(1, "EnergyPlus Version", "Current Time"); From b183b89eebe71900e8f910620ec20777351af488 Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 10:46:26 -0600 Subject: [PATCH 07/12] Fix in .hh too --- src/EnergyPlus/FuelCellElectricGenerator.hh | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/EnergyPlus/FuelCellElectricGenerator.hh b/src/EnergyPlus/FuelCellElectricGenerator.hh index 6a3e148b9a9..0cc972c4e5e 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.hh +++ b/src/EnergyPlus/FuelCellElectricGenerator.hh @@ -125,20 +125,20 @@ namespace FuelCellElectricGenerator { bool DuringShutDown; bool DuringStartUp; Real64 NdotFuel; // molar fuel use rate. (kmol/sec) - Real64 TotFuelInEnthalphy; // Enthalpy of fuel coming into FCPM (watts) + Real64 TotFuelInEnthalpy; // Enthalpy of fuel coming into FCPM (watts) Real64 NdotProdGas; // (kmol/sec) Array1D ConstitMolalFract; Array1D GasLibID; // lookup ID in Gas Phase ThermoChemistry Structure Array Real64 TprodGasLeavingFCPM; Real64 NdotAir; // molar air use rate (kmol/sec) - Real64 TotAirInEnthalphy; // Enthalpy of air coming nto FCPM energy balance (watts) + Real64 TotAirInEnthalpy; // Enthalpy of air coming nto FCPM energy balance (watts) Real64 NdotLiqwater; // molar water use rate (kmol/sec) Real64 TwaterInlet; Real64 WaterInEnthalpy; // Enthalpy of liquid water used for reforming (watts) Real64 DilutionAirInEnthalpy; // Enthalpy of Dilution air coming into FCPM (watts) Real64 DilutionAirOutEnthalpy; Real64 PelancillariesAC; // ancillary power (watts) - Real64 TotProdGasEnthalphy; // Enthalphy of product gases leaving FCPM (watts) + Real64 TotProdGasEnthalpy; // Enthalpy of product gases leaving FCPM (watts) Real64 WaterOutEnthalpy; // enthalpy of vapor from water used for reforming int SeqSubstitIter; int RegulaFalsiIter; @@ -151,10 +151,10 @@ namespace FuelCellElectricGenerator { SkinLossMode(DataGenerators::SkinLoss::Invalid), ZoneID(0), RadiativeFract(0.0), QdotSkin(0.0), UAskin(0.0), SkinLossCurveID(0), WaterSupplyCurveID(0), NdotDilutionAir(0.0), StackHeatLossToDilution(0.0), DilutionInletNode(0), DilutionExhaustNode(0), PelMin(0.0), PelMax(0.0), Pel(0.0), PelLastTimeStep(0.0), Eel(0.0), QdotStackCool(0.0), FractionalDayofLastStartUp(0.0), - FractionalDayofLastShutDown(0.0), HasBeenOn(true), DuringShutDown(false), DuringStartUp(false), NdotFuel(0.0), TotFuelInEnthalphy(0.0), + FractionalDayofLastShutDown(0.0), HasBeenOn(true), DuringShutDown(false), DuringStartUp(false), NdotFuel(0.0), TotFuelInEnthalpy(0.0), NdotProdGas(0.0), ConstitMolalFract(14, 0.0), GasLibID(14, GasID::Invalid), TprodGasLeavingFCPM(0.0), NdotAir(0.0), - TotAirInEnthalphy(0.0), NdotLiqwater(0.0), TwaterInlet(0.0), WaterInEnthalpy(0.0), DilutionAirInEnthalpy(0.0), - DilutionAirOutEnthalpy(0.0), PelancillariesAC(0.0), TotProdGasEnthalphy(0.0), WaterOutEnthalpy(0.0), SeqSubstitIter(0), + TotAirInEnthalpy(0.0), NdotLiqwater(0.0), TwaterInlet(0.0), WaterInEnthalpy(0.0), DilutionAirInEnthalpy(0.0), + DilutionAirOutEnthalpy(0.0), PelancillariesAC(0.0), TotProdGasEnthalpy(0.0), WaterOutEnthalpy(0.0), SeqSubstitIter(0), RegulaFalsiIter(0) { } @@ -401,7 +401,7 @@ namespace FuelCellElectricGenerator { Real64 TairInlet; // State point 1 Real64 TairIntoFCPM; // Temperature at State point 4 Real64 NdotAir; // air flow in kmol/sec - Real64 TotAirInEnthalphy; // Enthalpy at State point 4 + Real64 TotAirInEnthalpy; // Enthalpy at State point 4 Real64 BlowerPower; // electrical power used by air supply blower Real64 BlowerEnergy; // electrical energy used by air supply blower Real64 BlowerSkinLoss; // heat rate of losses by blower @@ -463,7 +463,7 @@ namespace FuelCellElectricGenerator { FCReportDataStruct() : ACPowerGen(0.0), ACEnergyGen(0.0), QdotExhaust(0.0), TotalHeatEnergyRec(0.0), ExhaustEnergyRec(0.0), FuelEnergyLHV(0.0), FuelEnergyUseRateLHV(0.0), FuelEnergyHHV(0.0), FuelEnergyUseRateHHV(0.0), FuelRateMdot(0.0), HeatRecInletTemp(0.0), - HeatRecOutletTemp(0.0), HeatRecMdot(0.0), TairInlet(0.0), TairIntoFCPM(0.0), NdotAir(0.0), TotAirInEnthalphy(0.0), BlowerPower(0.0), + HeatRecOutletTemp(0.0), HeatRecMdot(0.0), TairInlet(0.0), TairIntoFCPM(0.0), NdotAir(0.0), TotAirInEnthalpy(0.0), BlowerPower(0.0), BlowerEnergy(0.0), BlowerSkinLoss(0.0), TfuelInlet(0.0), TfuelIntoFCPM(0.0), NdotFuel(0.0), TotFuelInEnthalpy(0.0), FuelCompressPower(0.0), FuelCompressEnergy(0.0), FuelCompressSkinLoss(0.0), TwaterInlet(0.0), TwaterIntoFCPM(0.0), NdotWater(0.0), WaterPumpPower(0.0), WaterPumpEnergy(0.0), WaterIntoFCPMEnthalpy(0.0), TprodGas(0.0), EnthalProdGas(0.0), NdotProdGas(0.0), From de50c208624c3b1b774b71083bde6e3da18bd338 Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Mon, 23 Sep 2024 11:08:42 -0600 Subject: [PATCH 08/12] clang-format --- src/EnergyPlus/FuelCellElectricGenerator.hh | 32 ++++++++++----------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/EnergyPlus/FuelCellElectricGenerator.hh b/src/EnergyPlus/FuelCellElectricGenerator.hh index 0cc972c4e5e..7475d9bb8bf 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.hh +++ b/src/EnergyPlus/FuelCellElectricGenerator.hh @@ -124,22 +124,22 @@ namespace FuelCellElectricGenerator { bool HasBeenOn; bool DuringShutDown; bool DuringStartUp; - Real64 NdotFuel; // molar fuel use rate. (kmol/sec) - Real64 TotFuelInEnthalpy; // Enthalpy of fuel coming into FCPM (watts) - Real64 NdotProdGas; // (kmol/sec) + Real64 NdotFuel; // molar fuel use rate. (kmol/sec) + Real64 TotFuelInEnthalpy; // Enthalpy of fuel coming into FCPM (watts) + Real64 NdotProdGas; // (kmol/sec) Array1D ConstitMolalFract; Array1D GasLibID; // lookup ID in Gas Phase ThermoChemistry Structure Array Real64 TprodGasLeavingFCPM; - Real64 NdotAir; // molar air use rate (kmol/sec) - Real64 TotAirInEnthalpy; // Enthalpy of air coming nto FCPM energy balance (watts) - Real64 NdotLiqwater; // molar water use rate (kmol/sec) + Real64 NdotAir; // molar air use rate (kmol/sec) + Real64 TotAirInEnthalpy; // Enthalpy of air coming nto FCPM energy balance (watts) + Real64 NdotLiqwater; // molar water use rate (kmol/sec) Real64 TwaterInlet; Real64 WaterInEnthalpy; // Enthalpy of liquid water used for reforming (watts) Real64 DilutionAirInEnthalpy; // Enthalpy of Dilution air coming into FCPM (watts) Real64 DilutionAirOutEnthalpy; - Real64 PelancillariesAC; // ancillary power (watts) - Real64 TotProdGasEnthalpy; // Enthalpy of product gases leaving FCPM (watts) - Real64 WaterOutEnthalpy; // enthalpy of vapor from water used for reforming + Real64 PelancillariesAC; // ancillary power (watts) + Real64 TotProdGasEnthalpy; // Enthalpy of product gases leaving FCPM (watts) + Real64 WaterOutEnthalpy; // enthalpy of vapor from water used for reforming int SeqSubstitIter; int RegulaFalsiIter; @@ -398,13 +398,13 @@ namespace FuelCellElectricGenerator { Real64 HeatRecOutletTemp; // reporting: Heat Recovery Loop Outlet Temperature (C) Real64 HeatRecMdot; // reporting: Heat Recovery Loop Mass flow rate (kg/s) // air supply and blower - Real64 TairInlet; // State point 1 - Real64 TairIntoFCPM; // Temperature at State point 4 - Real64 NdotAir; // air flow in kmol/sec - Real64 TotAirInEnthalpy; // Enthalpy at State point 4 - Real64 BlowerPower; // electrical power used by air supply blower - Real64 BlowerEnergy; // electrical energy used by air supply blower - Real64 BlowerSkinLoss; // heat rate of losses by blower + Real64 TairInlet; // State point 1 + Real64 TairIntoFCPM; // Temperature at State point 4 + Real64 NdotAir; // air flow in kmol/sec + Real64 TotAirInEnthalpy; // Enthalpy at State point 4 + Real64 BlowerPower; // electrical power used by air supply blower + Real64 BlowerEnergy; // electrical energy used by air supply blower + Real64 BlowerSkinLoss; // heat rate of losses by blower // fuel supply and compressor Real64 TfuelInlet; // State point 2 [C] Real64 TfuelIntoFCPM; // state point 5 [C] From 6ff017054aee93fc918f1b0aee2a994a7d2c00cc Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Fri, 27 Sep 2024 17:12:45 -0600 Subject: [PATCH 09/12] Fix wrong name [ci skip] --- .../src/overview/group-performance-curves.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/input-output-reference/src/overview/group-performance-curves.tex b/doc/input-output-reference/src/overview/group-performance-curves.tex index 37a96ce5ae7..6f8f877b647 100644 --- a/doc/input-output-reference/src/overview/group-performance-curves.tex +++ b/doc/input-output-reference/src/overview/group-performance-curves.tex @@ -1066,7 +1066,7 @@ \subsubsection{Inputs}\label{inputs-6-016} \subsection{Curve:Biquadratic}\label{curvebiquadratic} -This curve is a function of two independent variables. Input consists of the curve name, the six coefficients, and min and max values for each of the independent variables. Optional inputs for curve minimum and maximum may be used to limit the output of the performance curve (e.g., limit extrapolation). The equation represented by the bicubic curve is: +This curve is a function of two independent variables. Input consists of the curve name, the six coefficients, and min and max values for each of the independent variables. Optional inputs for curve minimum and maximum may be used to limit the output of the performance curve (e.g., limit extrapolation). The equation represented by the biquadratic curve is: \begin{equation} z = {C_1} + {C_2}*x + {C_3}*{x^2} + {C_4}*y + {C_5}*{y^2} + {C_6}*xy From 99bbedb869f4c477509dd143c679de7d15f17cc6 Mon Sep 17 00:00:00 2001 From: Scott Horowitz Date: Thu, 10 Oct 2024 06:54:40 -0600 Subject: [PATCH 10/12] Fix a few labels for bigladder html docs. --- doc/input-output-reference/src/overview/group-airflow.tex | 2 +- doc/input-output-reference/src/overview/group-daylighting.tex | 4 ++-- .../src/overview/group-heating-and-cooling-coils.tex | 2 +- .../src/overview/group-operational-faults.tex | 4 ++-- .../src/overview/group-simulation-parameters.tex | 4 ++-- .../src/overview/group-surface-construction-elements.tex | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/doc/input-output-reference/src/overview/group-airflow.tex b/doc/input-output-reference/src/overview/group-airflow.tex index f70b854e548..218ac1dab71 100644 --- a/doc/input-output-reference/src/overview/group-airflow.tex +++ b/doc/input-output-reference/src/overview/group-airflow.tex @@ -1927,7 +1927,7 @@ \subsubsection{Outputs}\label{zoneearthtube-outputs} This is the wet bulb temperature of the air entering the zone after passing through the earth tube {[}C{]}. -\paragraph{Earth Tube Zone Inlet Humidity Ratio {[}kgWater/krDryAir{]}}\label{earth-tube-zone-inlet-humidity-ratio-kgWater/kgDryAir} +\paragraph{Earth Tube Zone Inlet Humidity Ratio {[}kgWater/krDryAir{]}}\label{earth-tube-zone-inlet-humidity-ratio-kgWater-kgDryAir} This is the humidity ratio of the air entering the zone after passing through the earth tube {[}kgWater/kgDryAir{]}. diff --git a/doc/input-output-reference/src/overview/group-daylighting.tex b/doc/input-output-reference/src/overview/group-daylighting.tex index 769bf3ae999..cedc47a96e2 100644 --- a/doc/input-output-reference/src/overview/group-daylighting.tex +++ b/doc/input-output-reference/src/overview/group-daylighting.tex @@ -20,7 +20,7 @@ \subsubsection{Inputs}\label{inputs-009} The name of the \hyperref[zone]{Zone} or \hyperref[space]{Space} to which the following daylighting-related input applies. If a zone name is specified, the zone must lie completely within a single solar enclosure. -\paragraph{Field: Daylighting Method}\label{field-Daylighting Method} +\paragraph{Field: Daylighting Method}\label{field-daylighting-method} The Daylighting Method field can be set to either of the following: SplitFlux or DElight. Different Zones can have different settings in the same file but in a single zone only one method should be used at a time. Guidelines for using the SplitFlux method and additional details on the DElight method are shown in following sections. @@ -89,7 +89,7 @@ \subsubsection{Inputs}\label{inputs-009} May be specified if a stepped lighting control system (Lighting Control Type set to Stepped) is manually operated, such as in a simple, one-step (on-off) system. Gives the probability the occupants of a daylit zone will set the electric lights to the correct level to obtain the required illuminance. The rest of the time the lights are assumed to be set one step too high. For example, consider an on-off lighting system (Number of Steps = 1) with a set point of 600 lux and 0.7 reset probability. Then, when daylighting exceeds 600 lux, the electric lights will be off 70\% of the time and on 30\% of the time. -\paragraph{Field: Glare Calculation Daylighting Reference Point Name}\label{field-glare calculation-daylighting-reference-point-name} +\paragraph{Field: Glare Calculation Daylighting Reference Point Name}\label{field-glare-calculation-daylighting-reference-point-name} The \hyperref[daylightingreferencepoint-000]{Daylighting:ReferencePoint} name should be specified that is used for determining the glare. Only one reference point is used to calculate the glare. This input is only used in when the Daylighting Method is set to SplitFlux. This input is ignored when Daylighting Method is set to DElight. diff --git a/doc/input-output-reference/src/overview/group-heating-and-cooling-coils.tex b/doc/input-output-reference/src/overview/group-heating-and-cooling-coils.tex index 9581e3197ee..a572b80ac56 100644 --- a/doc/input-output-reference/src/overview/group-heating-and-cooling-coils.tex +++ b/doc/input-output-reference/src/overview/group-heating-and-cooling-coils.tex @@ -4222,7 +4222,7 @@ \subsubsection{Inputs}\label{inputs-19-001} This numeric field defines the capacity of the resistive defrost heating element in Watts. This input field is used only when the selected defrost strategy is resistive (see input field Defrost Strategy above). The value for this input field must be greater than or equal to 0. If this input field is left blank, the default value is 0. -\paragraph{Field: Region Number for Calculating HSPF (2017) and HSPF2 (2023)}\label{field-region-number-for-calculating-HSPF-(2017)-and-hspf2-(2023)} +\paragraph{Field: Region Number for Calculating HSPF (2017) and HSPF2 (2023)}\label{field-region-number-for-calculating-HSPF-2017-and-hspf2-2023} This optional numeric field defines the region number which is used in calculating the Heating Seasonal Performance Factor (HSPF (2017 ANSI/AHRI standard) and HSPF2 (2023 ANSI/AHRI standard)) of heating coils. The value for this input field must be between 1 and 6. If this input field is left blank, the default value is 4. diff --git a/doc/input-output-reference/src/overview/group-operational-faults.tex b/doc/input-output-reference/src/overview/group-operational-faults.tex index abfdb1346f7..54e19388df9 100644 --- a/doc/input-output-reference/src/overview/group-operational-faults.tex +++ b/doc/input-output-reference/src/overview/group-operational-faults.tex @@ -857,11 +857,11 @@ \subsubsection{Inputs} This field provides the name of a schedule that represents severity of a fault. This schedule should be set to a non-zero value when a fault is applicable and 0.0 when it is not. If this field is blank, the schedule has values of 1 for all time periods. This is used to increase or decrease the fouling by a percentage. For example, if the schedule has a value of 1.2, it implies 20\% more fouling: if the Fouling Factor is 0.8, then resulting Fouling Factor would be $0.8 / 1.2 = 0.67$. -\paragraph{Field: Evaporative Cooler Object Type}\label{field-evaporative cooler-object-type} +\paragraph{Field: Evaporative Cooler Object Type}\label{field-evaporative-cooler-object-type} This field defines the evaporative cooler object type that this fault is associated with. Choices are the wetted coil evaporative coolers. -\paragraph{Field: Evaporative Cooler Object Name}\label{field-evaporative cooler-object-name} +\paragraph{Field: Evaporative Cooler Object Name}\label{field-evaporative-cooler-object-name} This field defines the name of the evaporative cooler object associated with the fault. It should be one of the objects with the defined types. diff --git a/doc/input-output-reference/src/overview/group-simulation-parameters.tex b/doc/input-output-reference/src/overview/group-simulation-parameters.tex index 133543c557a..a8483b4722b 100644 --- a/doc/input-output-reference/src/overview/group-simulation-parameters.tex +++ b/doc/input-output-reference/src/overview/group-simulation-parameters.tex @@ -618,10 +618,10 @@ \subsubsection{Inputs}\label{inputs-10-019} This field applies to the shading calculation update frequency method called ``Periodic.'' When the method called ``Timestep'' is used the diffuse sky modeling always uses DetailedSkyDiffuseModeling. -\paragraph{Field: Output External Shading Calculation Results}\label{field-output-external-shading-calculation results} +\paragraph{Field: Output External Shading Calculation Results}\label{field-output-external-shading-calculation-results} This fields indicates whether or not (\textbf{Yes} or \textbf{No})to save internal shading calculation results to an external file, which can be imported back as needed. This file saves external sunlit fractions for all surfaces. If \textbf{Yes} is chosen, hourly shading fraction of all surfaces will be exported as a CSV file, naming as "output file prefix + shading" (the default name is "eplusshading.csv" if no output file prefix is defined). Each column of the CSV file lists the annually calculated shading fraction of each surface with time-step interval. It only writes data for each simulation day that shadows are calculated, e.g. once every 20 days by default. If the results are intended to be reused to be imported back using \textbf{Imported} in \textbf{\hyperref[field-shading-calculation-method]{Field: Shading Calculation Method}}, the Calculation Frequency should be set as one to write year-round hourly results. Design days are not included. The default choice is \textbf{No}. -\paragraph{Field: Disable Self-Shading Within Shading Zone Groups}\label{fieldself--disable-shading-within-a-zone-group} +\paragraph{Field: Disable Self-Shading Within Shading Zone Groups}\label{field-self--disable-shading-within-a-zone-group} This fields specifies during shading calculation, for all surfaces in a targeted Zone Group, whether or not (\textbf{Yes} or \textbf{No} ) the self-shading effect by exterior surfaces of all zones within the target Zone Group is disabled. If Yes, self-shading will be disabled from all exterior surfaces in a given Shading Zone Group to surfaces within the same Shading Zone Group. If both Disable Self-Shading Within Shading Zone Groups and Disable Self-Shading From Shading Zone Groups to Other Zones = Yes, then all self-shading from exterior surfaces will be disabled.If only one of these fields = Yes, then at least one Shading Zone Group must be specified, or this field will be ignored. Shading from Shading:* surfaces, overhangs, fins, and reveals will not be disabled. \paragraph{Field: Disable Self-Shading From Shading Zone Groups to Other Zones}\label{field-self-disable-shading-between-zone-groups} diff --git a/doc/input-output-reference/src/overview/group-surface-construction-elements.tex b/doc/input-output-reference/src/overview/group-surface-construction-elements.tex index a32a8141b4f..98f0b9b038a 100644 --- a/doc/input-output-reference/src/overview/group-surface-construction-elements.tex +++ b/doc/input-output-reference/src/overview/group-surface-construction-elements.tex @@ -4118,7 +4118,7 @@ \subsubsection{Outputs}\label{outputs-36-1} This output is the temperature within the surface at the location of the source/sink. -\paragraph{Surface Internal User Specified Location Temperature {[}C{]}}\label{surface-internal-user—specified-location-temperature-c} +\paragraph{Surface Internal User Specified Location Temperature {[}C{]}}\label{surface-internal-user-specified-location-temperature-c} This output is the temperature within the surface at the location requested by the user. From e9645a5f1fc72b1cf6c84c7e6bb4d5d0a8b7105f Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Mon, 21 Oct 2024 14:54:00 -0500 Subject: [PATCH 11/12] Output changes --- .../OutputChanges24-2-0-to-25-1-0.md | 15 +++++++++++++++ .../Report Variables 24-2-0 to 25-1-0.csv | 4 +++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md b/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md index 2fe8ffb55ce..11d99f99481 100644 --- a/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md +++ b/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md @@ -6,3 +6,18 @@ This file documents the structural changes on the output of EnergyPlus that coul ### Description This will eventually become a more structured file, but currently it isn't clear what format is best. As an intermediate solution, and to allow the form to be formed organically, this plain text file is being used. Entries should be clearly delimited. It isn't expected that there will be but maybe a couple each release at most. Entries should also include some reference back to the repo. At least a PR number or whatever. + +### Table Output and Output:Variable Spelling Corrections +* "Equipment Summary" table report, sub-table "VAV DX Cooling Standard Rating Details", column heading, "Assocated Fan" --> "Associated Fan". + +* "Equipment Summary" table report, sub-table "Air Heat Recovery", column "Input object type", "Dessicant Balanced" --> "Desiccant Balanced" (for object type HeatExchanger:Desiccant:BalancedFlow). + +* Output:Variable "Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Tansfer Energy" --> "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Heat Transfer Energy". + +* Output:Variable "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Tansfer Energy" --> "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Transfer Energy". + +* Sizing output for ZoneHVAC:Baseboard:RadiantConvective:Steam, "User-Speicified Maximum Steam Flow Rate [m3/s]" --> "User-Specified Maximum Steam Flow Rate [m3/s]". + +* eio output header for "\", "Contruction" --> "Construction". Also appears in the "Initialization Summary" table output, "ShadingProperty Reflectance" sub-table, column heading. + +See Pull Request [#10760](https://github.com/NREL/EnergyPlus/pull/10760). diff --git a/src/Transition/SupportFiles/Report Variables 24-2-0 to 25-1-0.csv b/src/Transition/SupportFiles/Report Variables 24-2-0 to 25-1-0.csv index e5711517e60..07515537716 100644 --- a/src/Transition/SupportFiles/Report Variables 24-2-0 to 25-1-0.csv +++ b/src/Transition/SupportFiles/Report Variables 24-2-0 to 25-1-0.csv @@ -1,2 +1,4 @@ 24.2.0,25.1.0,Transition notes - some of these are EMS variable names -0,0,These numbers should be the number of report variables in the following list (including deletes). Two columns/numbers. +2,2,These numbers should be the number of report variables in the following list (including deletes). Two columns/numbers. +Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Tansfer Energy,Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Heat Transfer Energy, +Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Tansfer Energy,Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Transfer Energy, From 1266e17a2e078064038579f3aa305b25466f1fd4 Mon Sep 17 00:00:00 2001 From: "Michael J. Witte" Date: Thu, 24 Oct 2024 17:11:17 -0500 Subject: [PATCH 12/12] Output changes --- .../OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md b/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md index 11d99f99481..88c69eb9946 100644 --- a/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md +++ b/src/Transition/OutputRulesFiles/OutputChanges24-2-0-to-25-1-0.md @@ -7,7 +7,7 @@ This file documents the structural changes on the output of EnergyPlus that coul This will eventually become a more structured file, but currently it isn't clear what format is best. As an intermediate solution, and to allow the form to be formed organically, this plain text file is being used. Entries should be clearly delimited. It isn't expected that there will be but maybe a couple each release at most. Entries should also include some reference back to the repo. At least a PR number or whatever. -### Table Output and Output:Variable Spelling Corrections +### Table Output, Sizing Output, and Output:Variable Spelling Corrections * "Equipment Summary" table report, sub-table "VAV DX Cooling Standard Rating Details", column heading, "Assocated Fan" --> "Associated Fan". * "Equipment Summary" table report, sub-table "Air Heat Recovery", column "Input object type", "Dessicant Balanced" --> "Desiccant Balanced" (for object type HeatExchanger:Desiccant:BalancedFlow). @@ -18,6 +18,8 @@ This will eventually become a more structured file, but currently it isn't clear * Sizing output for ZoneHVAC:Baseboard:RadiantConvective:Steam, "User-Speicified Maximum Steam Flow Rate [m3/s]" --> "User-Specified Maximum Steam Flow Rate [m3/s]". +* Sizing output for Chiller:Absorption, "Iniital Design Size Design Generator Fluid Flow Rate [m3/s]" --> "Initial Design Size Design Generator Fluid Flow Rate [m3/s]" + * eio output header for "\", "Contruction" --> "Construction". Also appears in the "Initialization Summary" table output, "ShadingProperty Reflectance" sub-table, column heading. See Pull Request [#10760](https://github.com/NREL/EnergyPlus/pull/10760).