Merge remote-tracking branch 'origin/develop' into finish_removing_gio

.github/workflows/doc-problem-match.json

@@ -0,0 +1,16 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "latex-parser",
+      "pattern": [
+        {
+          "regexp": "^\\[LATEX(WARNING|ERROR)::(.*?):(\\d+)::(.*?)\\]$",
+          "severity": 1,
+          "file": 2,
+          "line": 3,
+          "message": 4
+        }
+      ]
+    }
+  ]
+}

.github/workflows/documentation.yml

@@ -23,7 +23,10 @@ jobs:
 
     - name: Configure CMake
       working-directory: ${{runner.workspace}}/EnergyPlus/doc/build
-      run: cmake -DTEX_INTERACTION=batchmode ..
+      run: cmake -DTEX_INTERACTION=batchmode -DDOCS_TESTING=ON ..
+
+    - name: Add problem matcher
+      run: echo "::add-matcher::.github/workflows/doc-problem-match.json"
 
     - name: Build Docs
       working-directory: ${{runner.workspace}}/EnergyPlus/doc/build

doc/tools/parse_latex_log.py

@@ -168,40 +168,6 @@ def find_multiply_defined_labels(root_dir, label):
     target = "\\label{" + label + "}"
     return find_locations(root_dir, target)
 
-
-def parse_warning(line, src_dir):
-    """
-    - line: string, the line to parse
-    - src_dir: string, the root directory of the LaTeX source files
-    RETURN: None or one of:
-    - {'type': 'Label multiply defined',
-       'label': string,
-       'message': string}
-    - {'type': 'Hyper reference undefined',
-       'label': string,
-       'message': string}
-    """
-    m = LABEL_MULTIPLY_DEFINED_WARN.match(line)
-    if m is not None:
-        label = m.group(1)
-        locations = find_multiply_defined_labels(src_dir, label)
-        return {'severity': SEVERITY_WARNING,
-                'type': "Label multiply defined",
-                'locations': locations,
-                'message': line,
-                'label': m.group(1)}
-    m = HYPER_UNDEFINED_WARN.match(line)
-    if m is not None:
-        label = m.group(1)
-        locations = find_undefined_hyperref(src_dir, label)
-        return {'severity': SEVERITY_WARNING,
-                'type': "Hyper reference undefined",
-                'locations': locations,
-                'message': line,
-                'label': m.group(1)}
-    return None
-
-
 def parse_line_number(message):
     """
     - message: string
@@ -233,53 +199,68 @@ def __init__(self, log_path, src_dir, verbose=False):
         self.src_dir = src_dir
         self.verbose = verbose
 
-    def _read_tex_error(self, line):
+    def _read_tex_error(self):
         line_no = parse_line_number(self._current_issue)
         self._issues['issues'].append({
-            'severity': SEVERITY_ERROR,
+            'level': SEVERITY_ERROR,
             'type': self._type,
-            'locations': [{
-                'file': self._current_tex_file,
-                'line': line_no}],
+            'path': self._current_tex_file,
+            'line': {"start": line_no, "end": line_no},
             'message': self._current_issue.strip()})
 
-    def _read_warning(self, line):
-        warn = parse_warning(self._current_issue, self.src_dir)
-        if self._current_issue.strip() not in ISSUES_TO_SKIP:
-            if warn is not None:
-                self._issues['issues'].append(warn)
-            else:
-                line_no = parse_on_input_line(self._current_issue)
-                self._issues['issues'].append({
-                    'severity': SEVERITY_WARNING,
-                    'type': self._type,
-                    'locations': [{
-                        'file': self._current_tex_file,
-                        'line': line_no}],
-                    'message': self._current_issue.strip()})
-
-    def _read_error(self, line):
-        if self._current_issue not in ISSUES_TO_SKIP:
+    def _read_warning(self):
+        warns = []
+        m1 = LABEL_MULTIPLY_DEFINED_WARN.match(self._current_issue)
+        m2 = HYPER_UNDEFINED_WARN.match(self._current_issue)
+        if m1 is not None:
+            label = m1.group(1)
+            locations = find_multiply_defined_labels(self.src_dir, label)
+            for loc in locations:
+                warns.append({
+                    'level': SEVERITY_WARNING,
+                    'type': "Label multiply defined",
+                    'path': loc["file"],
+                    'line': {"start": loc["line"], "end": loc["line"]},
+                    'message': self._current_issue.strip(),
+                    'label': m1.group(1)
+                })
+        elif m2 is not None:
+            label = m2.group(1)
+            locations = find_undefined_hyperref(self.src_dir, label)
+            for loc in locations:
+                warns.append({
+                    'level': SEVERITY_WARNING,
+                    'type': "Hyper reference undefined",
+                    'path': loc["file"],
+                    'line': {"start": loc["line"], "end": loc["line"]},
+                    'message': self._current_issue.strip(),
+                    'label': m2.group(1)
+                })
+        elif self._current_issue.strip() not in ISSUES_TO_SKIP:
             line_no = parse_on_input_line(self._current_issue)
-            self._issues['issues'].append({
-                'severity': SEVERITY_ERROR,
+            warns = [{
+                'level': SEVERITY_WARNING,
                 'type': self._type,
-                'locations': [{
-                    'file': self._current_tex_file,
-                    'line': line_no}],
-                'message': self._current_issue.strip()})
+                'path': self._current_tex_file,
+                'line': {"start": line_no, "end": line_no},
+                'message': self._current_issue.strip()}]
+        self._issues['issues'] += warns
+
+    def _read_error(self):
+        if self._current_issue not in ISSUES_TO_SKIP:
+            self._read_tex_error()
 
     def _read_issue(self, line):
         is_ws = (line.strip() == "")
         first_line = (self._issue_line == 1)
         nonempty = len(line) > 1
         if is_ws and (not (first_line and nonempty)):
             if self._in_tex_err:
-                self._read_tex_error(line)
+                self._read_tex_error()
             elif self._in_warn:
-                self._read_warning(line)
+                self._read_warning()
             elif self._in_err:
-                self._read_error(line)
+                self._read_error()
             else:
                 raise Exception("unhandled issue read")
             self._reset_after_read()
@@ -388,16 +369,10 @@ def update_paths_to_be_from_repo_root(issues, repo_root_to_src):
     updated = []
     for issue in issues:
         update = copy.deepcopy(issue)
-        if 'locations' in update:
-            new_locs = []
-            for location in update['locations']:
-                loc = copy.deepcopy(location)
-                if 'file' in location:
-                    loc['file'] = os.path.join(
-                            repo_root_to_src,
-                            location['file'])
-                new_locs.append(loc)
-            update['locations'] = new_locs
+        if 'path' in update:
+            update['path'] = os.path.join(
+                    repo_root_to_src,
+                    update['path'])
         updated.append(update)
     return updated
 
@@ -440,16 +415,14 @@ def find_issues(log_path, json_error_path, src_dir):
         f = sys.stdout
         for issue in errs['issues']:
             f.write("[LATEX")
-            f.write(issue['severity'] + "::")
-            locs = [loc['file'] + ":" + str(loc['line'])
-                    for loc in issue['locations']]
-            f.write(",".join(locs) + "::")
+            f.write(issue['level'] + "::")
+            f.write(issue['path'] + ":" + str(issue["line"]["start"]))
             msg = issue['message'].replace("\r\n", " ")
             msg = msg.replace("\n", " ")
             msg = msg.replace("\r", " ")
             msg = msg.replace("\t", " ")
             msg = " ".join(msg.split())
-            f.write(msg + "]\n")
+            f.write("::" + msg + "]\n")
         with open(json_error_path, 'w', encoding='utf-8') as f:
             json.dump(errs, f, ensure_ascii=False, indent=4)
     return (num_issues > 0)

src/EnergyPlus/AirLoopHVACDOAS.cc

@@ -161,7 +161,8 @@ namespace AirLoopHVACDOAS {
                 thisMixer.name = UtilityRoutines::MakeUPPERCase(thisObjectName);
                 thisMixer.OutletNodeName = UtilityRoutines::MakeUPPERCase(fields.at("outlet_node_name"));
                 thisMixer.m_AirLoopMixer_Num = AirLoopMixerNum - 1;
-                thisMixer.OutletNodeNum = NodeInputManager::GetOnlySingleNode(thisMixer.OutletNodeName,
+                thisMixer.OutletNodeNum = NodeInputManager::GetOnlySingleNode(state,
+                                                                              thisMixer.OutletNodeName,
                                                                               errorsFound,
                                                                               cCurrentModuleObject,
                                                                               thisObjectName,
@@ -518,9 +519,9 @@ namespace AirLoopHVACDOAS {
 
                     } else if (SELECT_CASE_var == "COIL:HEATING:STEAM") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
-                            SteamCoils::GetCoilSteamInletNode(CompType, CompName, InletNodeErrFlag);
+                            SteamCoils::GetCoilSteamInletNode(state, CompType, CompName, InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) =
-                            SteamCoils::GetCoilSteamOutletNode(CompType, CompName, OutletNodeErrFlag);
+                            SteamCoils::GetCoilSteamOutletNode(state, CompType, CompName, OutletNodeErrFlag);
                     } else if (SELECT_CASE_var == "COIL:COOLING:WATER:DETAILEDGEOMETRY") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) = WaterCoils::GetCoilInletNode(state,
                             SELECT_CASE_var, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
@@ -591,21 +592,21 @@ namespace AirLoopHVACDOAS {
                     } else if (SELECT_CASE_var == "HEATEXCHANGER:AIRTOAIR:FLATPLATE") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).HeatExchangerFlag = true;
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyInletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
+                            HeatRecovery::GetSupplyInletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyOutletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
+                            HeatRecovery::GetSupplyOutletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
                     } else if (SELECT_CASE_var == "HEATEXCHANGER:AIRTOAIR:SENSIBLEANDLATENT") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).HeatExchangerFlag = true;
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyInletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
+                            HeatRecovery::GetSupplyInletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyOutletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
+                            HeatRecovery::GetSupplyOutletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
                     } else if (SELECT_CASE_var == "HEATEXCHANGER:DESICCANT:BALANCEDFLOW") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).HeatExchangerFlag = true;
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyInletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
+                            HeatRecovery::GetSupplyInletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) =
-                            HeatRecovery::GetSupplyOutletNode(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
+                            HeatRecovery::GetSupplyOutletNode(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
                         // Desiccant Dehumidifier
                     } else if (SELECT_CASE_var == "DEHUMIDIFIER:DESICCANT:NOFANS") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) = DesiccantDehumidifiers::GetProcAirInletNodeNum(state,
@@ -631,15 +632,15 @@ namespace AirLoopHVACDOAS {
                         // Unglazed Transpired Solar Collector
                     } else if (SELECT_CASE_var == "SOLARCOLLECTOR:UNGLAZEDTRANSPIRED") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
-                            TranspiredCollector::GetAirInletNodeNum(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
+                            TranspiredCollector::GetAirInletNodeNum(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) =
-                            TranspiredCollector::GetAirOutletNodeNum(state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
+                            TranspiredCollector::GetAirOutletNodeNum(state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
                         // PVT air heater
                     } else if (SELECT_CASE_var == "SOLARCOLLECTOR:FLATPLATE:PHOTOVOLTAICTHERMAL") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) = PhotovoltaicThermalCollectors::GetAirInletNodeNum(
-                            state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
+                            state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), InletNodeErrFlag);
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).OutletNodeNum(CompNum) = PhotovoltaicThermalCollectors::GetAirOutletNodeNum(
-                            state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
+                            state, state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).ComponentName(CompNum), OutletNodeErrFlag);
                         // Evaporative Cooler Types
                     } else if (SELECT_CASE_var == "EVAPORATIVECOOLER:DIRECT:CELDEKPAD") {
                         state.dataAirLoop->OutsideAirSys(thisDOAS.m_OASystemNum).InletNodeNum(CompNum) =
@@ -703,7 +704,7 @@ namespace AirLoopHVACDOAS {
                 }
 
                 thisDOAS.AvailManagerSchedName = UtilityRoutines::MakeUPPERCase(fields.at("availability_schedule_name"));
-                thisDOAS.m_AvailManagerSchedPtr = GetScheduleIndex(thisDOAS.AvailManagerSchedName);
+                thisDOAS.m_AvailManagerSchedPtr = GetScheduleIndex(state, thisDOAS.AvailManagerSchedName);
                 if (thisDOAS.m_AvailManagerSchedPtr == 0) {
                     cFieldName = "Availability Schedule Name";
                     ShowSevereError(cCurrentModuleObject + ", \"" + thisDOAS.Name + "\" " + cFieldName +
@@ -811,8 +812,9 @@ namespace AirLoopHVACDOAS {
                 if (UtilityRoutines::SameString(CompType, "COIL:HEATING:WATER")) {
                     WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_HeatCoilNum);
                     Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", CompName, ErrorsFound);
-                    rho = FluidProperties::GetDensityGlycol(DataPlant::PlantLoop(this->HWLoopNum).FluidName,
-                                                            DataGlobals::HWInitConvTemp,
+                    rho = FluidProperties::GetDensityGlycol(state,
+                                                            DataPlant::PlantLoop(this->HWLoopNum).FluidName,
+                                                            DataGlobalConstants::HWInitConvTemp(),
                                                             DataPlant::PlantLoop(this->HWLoopNum).FluidIndex,
                                                             RoutineName);
                     PlantUtilities::InitComponentNodes(0.0,
@@ -827,8 +829,9 @@ namespace AirLoopHVACDOAS {
                 if (UtilityRoutines::SameString(CompType, "COIL:COOLING:WATER")) {
                     WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum);
                     Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water", CompName, ErrorsFound);
-                    rho = FluidProperties::GetDensityGlycol(DataPlant::PlantLoop(this->CWLoopNum).FluidName,
-                                                            DataGlobals::CWInitConvTemp,
+                    rho = FluidProperties::GetDensityGlycol(state,
+                                                            DataPlant::PlantLoop(this->CWLoopNum).FluidName,
+                                                            DataGlobalConstants::CWInitConvTemp(),
                                                             DataPlant::PlantLoop(this->CWLoopNum).FluidIndex,
                                                             RoutineName);
                     PlantUtilities::InitComponentNodes(0.0,
@@ -843,8 +846,9 @@ namespace AirLoopHVACDOAS {
                 if (UtilityRoutines::SameString(CompType, "COIL:COOLING:WATER:DETAILEDGEOMETRY")) {
                     WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum);
                     Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", CompName, ErrorsFound);
-                    rho = FluidProperties::GetDensityGlycol(DataPlant::PlantLoop(this->CWLoopNum).FluidName,
-                                                            DataGlobals::CWInitConvTemp,
+                    rho = FluidProperties::GetDensityGlycol(state,
+                                                            DataPlant::PlantLoop(this->CWLoopNum).FluidName,
+                                                            DataGlobalConstants::CWInitConvTemp(),
                                                             DataPlant::PlantLoop(this->CWLoopNum).FluidIndex,
                                                             RoutineName);
                     PlantUtilities::InitComponentNodes(0.0,

src/EnergyPlus/AirflowNetwork/include/AirflowNetwork/Properties.hpp

@@ -64,7 +64,7 @@
 
 #ifndef TOKELVIN
 #include "../../../DataGlobals.hh"
-#define TOKELVIN(T) (T + DataGlobals::KelvinConv)
+#define TOKELVIN(T) (T + DataGlobalConstants::KelvinConv())
 #else
 // Need a fallback
 #endif