Coil API Refactor (Part III -- move GetCoilInputs to init_state())

idd/embedded/generate_embeddable_epJSON_schema.cpp

@@ -1,22 +1,22 @@
-#include <cstdint>  // std::uint8_t
-#include <fstream>  // std::ifstream
+#include <cstdint> // std::uint8_t
+#include <fstream> // std::ifstream
 #include <stdexcept>
-#include <vector>  // std::vector
+#include <vector> // std::vector
 #ifndef __cppcheck__
-#  if __has_include(<filesystem>)
-#    include <filesystem>
+#if __has_include(<filesystem>)
+#include <filesystem>
 namespace fs = std::filesystem;
-#  elif __has_include(<experimental/filesystem>)
-#    include <experimental/filesystem>
+#elif __has_include(<experimental/filesystem>)
+#include <experimental/filesystem>
 namespace fs = std::experimental::filesystem;
-#  else
+#else
 // cppcheck-suppress preprocessorErrorDirective
-#    error "no filesystem support"
-#  endif
+#error "no filesystem support"
+#endif
 #endif
 
-#include <nlohmann/json.hpp>  // json
 #include <EnergyPlus/Formatters.hh>
+#include <nlohmann/json.hpp> // json
 
 using json = nlohmann::json;
 
@@ -98,9 +98,12 @@ static constexpr auto footer = R"cpp(
 } // namespace EnergyPlus
 )cpp";
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
   if (argc != 3) {
-    EnergyPlus::print(stderr, "usage: ./generate_embeddable_schema path/to/Energy+.schema.epJSON path/to/EmbeddedEpJSONSchema.cc\n");
+    EnergyPlus::print(
+        stderr,
+        "usage: ./generate_embeddable_schema path/to/Energy+.schema.epJSON "
+        "path/to/EmbeddedEpJSONSchema.cc\n");
     return 1;
   }
 
@@ -117,22 +120,27 @@ int main(int argc, char const* argv[]) {
   const fs::path outFilePath(argv[2]);
   const auto outFileDir = outFilePath.parent_path();
   if (!fs::is_directory(outFileDir)) {
-    EnergyPlus::print(stderr, "Output Directory does not exist: {}\n", outFileDir.generic_string());
+    EnergyPlus::print(stderr, "Output Directory does not exist: {}\n",
+                      outFileDir.generic_string());
     fs::create_directory(outFileDir);
   }
 
-  std::FILE* outfile = std::fopen(argv[2], "w");
+  std::FILE *outfile = std::fopen(argv[2], "w");
   if (outfile == nullptr) {
     EnergyPlus::print(stderr, "Could not open output file: {}\n", argv[2]);
     return 1;
   }
 
   EnergyPlus::print(outfile, "{}", header);
 
-  EnergyPlus::print(outfile, "    static constexpr std::array< std::uint8_t, {} > embeddedSchema = {{{{\n", v_cbor.size());
+  EnergyPlus::print(outfile,
+                    "    static constexpr std::array< std::uint8_t, {} > "
+                    "embeddedSchema = {{{{\n",
+                    v_cbor.size());
 
   for (size_t i = 0; i < v_cbor.size(); ++i) {
-    EnergyPlus::print(outfile, "{:#04x},", v_cbor[i]);  // Format the std::uint8_t as hex
+    EnergyPlus::print(outfile, "{:#04x},",
+                      v_cbor[i]); // Format the std::uint8_t as hex
     if (i % 40 == 0 && i != 0) {
       EnergyPlus::print(outfile, "\n");
     }

src/EnergyPlus/AirflowNetwork/src/Solver.cpp

@@ -12640,6 +12640,7 @@ namespace AirflowNetwork {
                         DuctSizingSBFlag = true;
                     }
                     while (NodeNum1 != NodeSplitter) {
+                        bool foundNextDuct = false;
                         for (AFNLinkNum1 = 1; AFNLinkNum1 <= AirflowNetworkNumOfLinks; AFNLinkNum1++) {
                             if (NodeNum1 != AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[0]) {
                                 continue;
@@ -12659,10 +12660,14 @@ namespace AirflowNetwork {
                                     DynamicLoss += disSysCompDuct.TurDynCoef;
                                     NodeNum1 = AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[1];
                                     DuctSizingSTFlag = true;
+                                    foundNextDuct = true;
                                     break;
                                 }
                             }
                         }
+                        if (!foundNextDuct) {
+                            break;
+                        }
                     }
                 }
                 if (DuctSizingSTFlag) {
@@ -12761,6 +12766,7 @@ namespace AirflowNetwork {
                         DuctSizingSBFlag = true;
                     }
                     while (NodeNum1 != NodeSplitter) {
+                        bool foundNextDuct = false;
                         for (AFNLinkNum1 = 1; AFNLinkNum1 <= AirflowNetworkNumOfLinks; AFNLinkNum1++) {
                             if (NodeNum1 != AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[1]) {
                                 continue;
@@ -12780,10 +12786,14 @@ namespace AirflowNetwork {
                                     DynamicLoss += disSysCompDuct.TurDynCoef;
                                     NodeNum1 = AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[0];
                                     DuctSizingSBFlag = true;
+                                    foundNextDuct = true;
                                     break;
                                 }
                             }
                         }
+                        if (!foundNextDuct) {
+                            break;
+                        }
                     }
                 }
                 if (DuctSizingSBFlag) {
@@ -12886,6 +12896,7 @@ namespace AirflowNetwork {
                         DuctSizingRTFlag = true;
                     }
                     while (NodeNum1 != NodeMixer) {
+                        bool foundNextDuct = false;
                         for (AFNLinkNum1 = 1; AFNLinkNum1 <= AirflowNetworkNumOfLinks; AFNLinkNum1++) {
                             if (NodeNum1 != AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[1]) {
                                 continue;
@@ -12905,10 +12916,14 @@ namespace AirflowNetwork {
                                     DynamicLoss += disSysCompDuct.TurDynCoef;
                                     NodeNum1 = AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[0];
                                     DuctSizingRTFlag = true;
+                                    foundNextDuct = true;
                                     break;
                                 }
                             }
                         }
+                        if (!foundNextDuct) {
+                            break;
+                        }
                     }
                 }
                 if (DuctSizingRTFlag) {
@@ -13009,6 +13024,7 @@ namespace AirflowNetwork {
                         DuctSizingRBFlag = true;
                     }
                     while (NodeNum1 != NodeMixer) {
+                        bool foundNextDuct = false;
                         for (AFNLinkNum1 = 1; AFNLinkNum1 <= AirflowNetworkNumOfLinks; AFNLinkNum1++) {
                             if (NodeNum1 != AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[0]) {
                                 continue;
@@ -13028,10 +13044,14 @@ namespace AirflowNetwork {
                                     DynamicLoss += disSysCompDuct.TurDynCoef;
                                     NodeNum1 = AirflowNetworkLinkageData(AFNLinkNum1).NodeNums[1];
                                     DuctSizingRBFlag = true;
+                                    foundNextDuct = true;
                                     break;
                                 }
                             }
                         }
+                        if (!foundNextDuct) {
+                            break;
+                        }
                     }
                 }
                 if (DuctSizingRBFlag) {

src/EnergyPlus/BranchInputManager.cc

@@ -1085,7 +1085,6 @@ namespace BranchInputManager {
                 cNumericFields.deallocate();
                 lAlphaBlanks.deallocate();
                 lNumericBlanks.deallocate();
-                Node::TestInletOutletNodes(state);
                 state.dataBranchInputManager->GetBranchInputOneTimeFlag = false;
             }
         }

src/EnergyPlus/BranchNodeConnections.cc

@@ -2039,6 +2039,16 @@ void SetUpCompSets(EnergyPlusData &state,
     Node::ConnectionObjectType ComponentTypeEnum = static_cast<Node::ConnectionObjectType>(getEnumValue(ConnectionObjectTypeNamesUC, CompTypeUC));
     assert(ComponentTypeEnum != Node::ConnectionObjectType::Invalid);
 
+    auto const compSetSource = [&]() {
+        if (ParentTypeEnum == Node::ConnectionObjectType::Undefined) {
+            return Node::CompSetSource::ComponentRegistration;
+        }
+        if (ParentTypeEnum == Node::ConnectionObjectType::Branch) {
+            return Node::CompSetSource::BranchTopology;
+        }
+        return Node::CompSetSource::ParentChild;
+    }();
+
     int Found = 0;
 
     // See if Component-Nodes set is already there - should be unique
@@ -2080,123 +2090,21 @@ void SetUpCompSets(EnergyPlusData &state,
             if (!Description.empty()) {
                 state.dataBranchNodeConnections->CompSets(Count).Description = Description;
             }
+            state.dataBranchNodeConnections->CompSets(Count).Source = compSetSource;
             Found = Count;
             break;
         }
     }
     if (Found == 0) {
         for (int Count = 1; Count <= state.dataBranchNodeConnections->NumCompSets; ++Count) {
-            Found = 0;
-            // Test if inlet node has been used before as an inlet node
-            // If the matching node name does not belong to the parent object, then error
-            // For example a fan may share the same inlet node as the furnace object which is its parent
             if (InletNode != state.dataBranchNodeConnections->CompSets(Count).InletNodeName) {
                 continue;
-                // If parent type is undefined then no error
-            }
-            if ((ParentTypeEnum == Node::ConnectionObjectType::Undefined) ||
-                (state.dataBranchNodeConnections->CompSets(Count).ParentObjectType == Node::ConnectionObjectType::Undefined)) {
-                // If node name is undefined then no error
-            } else if (InletNode != undefined) {
-                // If the matching node name does not belong to the parent or child object, then error
-                // For example a fan may share the same inlet node as the furnace object which is its parent
-                if ((ParentTypeEnum == state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType) &&
-                    (ParentName == state.dataBranchNodeConnections->CompSets(Count).CName)) {
-                    // OK - The duplicate inlet node belongs to this component's parent
-                } else if ((ComponentTypeEnum == state.dataBranchNodeConnections->CompSets(Count).ParentObjectType) &&
-                           (CompName == state.dataBranchNodeConnections->CompSets(Count).ParentCName)) {
-                    // OK - The duplicate inlet node belongs to a child of this component
-                } else {
-                    // Due to possibility of grandparents or more, if the matching node name
-                    // belongs to a component that appears as a parent, then OK
-                    int Found2 = 0;
-                    for (int Count2 = 1; Count2 <= state.dataBranchNodeConnections->NumCompSets; ++Count2) {
-                        if ((state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType ==
-                             state.dataBranchNodeConnections->CompSets(Count2).ParentObjectType) &&
-                            (state.dataBranchNodeConnections->CompSets(Count).CName ==
-                             state.dataBranchNodeConnections->CompSets(Count2).ParentCName)) {
-                            Found2 = 1;
-                        }
-                        if ((ComponentTypeEnum == state.dataBranchNodeConnections->CompSets(Count2).ParentObjectType) &&
-                            (CompName == state.dataBranchNodeConnections->CompSets(Count2).ParentCName)) {
-                            Found2 = 1;
-                        }
-                    }
-                    if (Found2 == 0) {
-                        ShowWarningError(state, std::format("Node used as an inlet more than once: {}", InletNode));
-                        ShowContinueError(
-                            state,
-                            std::format(
-                                "  Used by: {}, name={}",
-                                ConnectionObjectTypeNames[static_cast<int>(state.dataBranchNodeConnections->CompSets(Count).ParentObjectType)],
-                                state.dataBranchNodeConnections->CompSets(Count).ParentCName));
-                        ShowContinueError(
-                            state,
-                            std::format(
-                                "  as inlet for: {}, name={}",
-                                ConnectionObjectTypeNames[static_cast<int>(state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType)],
-                                state.dataBranchNodeConnections->CompSets(Count).CName));
-                        ShowContinueError(state, std::format("{}{}{}", "  and  by     : ", ParentTypeUC + ", name=", ParentName));
-                        ShowContinueError(state, std::format("{}{}{}", "  as inlet for: ", CompTypeUC + ", name=", CompName));
-                    }
-                }
             }
-            // Test if outlet node has been used before as an outlet node
-            // If the matching node name does not belong to the parent or child object, then error
-            // For example a fan may share the same outlet node as the furnace object which is its parent
             if (OutletNode != state.dataBranchNodeConnections->CompSets(Count).OutletNodeName) {
                 continue;
-                // If parent type is undefined then no error
-            }
-            if ((ParentTypeEnum == Node::ConnectionObjectType::Undefined) ||
-                (state.dataBranchNodeConnections->CompSets(Count).ParentObjectType == Node::ConnectionObjectType::Undefined)) {
-                // If node name is undefined then no error
-            } else if (OutletNode != undefined) {
-                if ((ParentTypeEnum == state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType) &&
-                    (ParentName == state.dataBranchNodeConnections->CompSets(Count).CName)) {
-                    // OK - The duplicate outlet node belongs to this component's parent
-                } else if ((ComponentTypeEnum == state.dataBranchNodeConnections->CompSets(Count).ParentObjectType) &&
-                           (CompName == state.dataBranchNodeConnections->CompSets(Count).ParentCName)) {
-                    // OK - The duplicate outlet node belongs to a child of this component
-                } else {
-                    // Due to possibility of grandparents or more, if the matching node name
-                    // belongs to a component that appears as a parent, then OK
-                    int Found2 = 0;
-                    for (int Count2 = 1; Count2 <= state.dataBranchNodeConnections->NumCompSets; ++Count2) {
-                        if ((state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType ==
-                             state.dataBranchNodeConnections->CompSets(Count2).ParentObjectType) &&
-                            (state.dataBranchNodeConnections->CompSets(Count).CName ==
-                             state.dataBranchNodeConnections->CompSets(Count2).ParentCName)) {
-                            Found2 = 1;
-                        }
-                        if ((ComponentTypeEnum == state.dataBranchNodeConnections->CompSets(Count2).ParentObjectType) &&
-                            (CompName == state.dataBranchNodeConnections->CompSets(Count2).ParentCName)) {
-                            Found2 = 1;
-                        }
-                    }
-                    // This rule is violated by dual duct units, so let it pass
-                    if (Found2 == 0) {
-                        std::string_view const CType =
-                            ConnectionObjectTypeNames[static_cast<int>(state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType)];
-                        if ((!has_prefixi(CType, "AirTerminal:DualDuct:")) && (!has_prefixi(CompTypeUC, "AirTerminal:DualDuct:"))) {
-                            ShowWarningError(state, std::format("Node used as an outlet more than once: {}", OutletNode));
-                            ShowContinueError(
-                                state,
-                                std::format(
-                                    "  Used by: {}, name={}",
-                                    ConnectionObjectTypeNames[static_cast<int>(state.dataBranchNodeConnections->CompSets(Count).ParentObjectType)],
-                                    state.dataBranchNodeConnections->CompSets(Count).ParentCName));
-                            ShowContinueError(
-                                state,
-                                std::format(
-                                    "  as outlet for: {}, name={}",
-                                    ConnectionObjectTypeNames[static_cast<int>(state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType)],
-                                    state.dataBranchNodeConnections->CompSets(Count).CName));
-                            ShowContinueError(state, std::format("{}{}{}", "  and  by     : ", ParentTypeUC + ", name=", ParentName));
-                            ShowContinueError(state, std::format("{}{}{}", "  as outlet for: ", CompTypeUC + ", name=", CompName));
-                        }
-                    }
-                }
+            }
+            if (compSetSource != state.dataBranchNodeConnections->CompSets(Count).Source) {
+                continue;
             }
             if (ComponentTypeEnum != state.dataBranchNodeConnections->CompSets(Count).ComponentObjectType &&
                 ComponentTypeEnum != Node::ConnectionObjectType::Undefined) {
@@ -2227,6 +2135,7 @@ void SetUpCompSets(EnergyPlusData &state,
         } else {
             state.dataBranchNodeConnections->CompSets(state.dataBranchNodeConnections->NumCompSets).Description = undefined;
         }
+        state.dataBranchNodeConnections->CompSets(state.dataBranchNodeConnections->NumCompSets).Source = compSetSource;
     }
 }
 
@@ -2243,11 +2152,14 @@ void TestInletOutletNodes(EnergyPlusData &state)
 
     Array1D_bool AlreadyNoted;
 
-    // Test component sets created by branches
+    // Test component sets created by branch input only.
     AlreadyNoted.dimension(state.dataBranchNodeConnections->NumCompSets, false);
     for (int Count = 1; Count <= state.dataBranchNodeConnections->NumCompSets; ++Count) {
+        if (state.dataBranchNodeConnections->CompSets(Count).Source != Node::CompSetSource::BranchTopology) {
+            continue;
+        }
         for (int Other = 1; Other <= state.dataBranchNodeConnections->NumCompSets; ++Other) {
-            if (Count == Other) {
+            if (Count == Other || state.dataBranchNodeConnections->CompSets(Other).Source != Node::CompSetSource::BranchTopology) {
                 continue;
             }
             if (state.dataBranchNodeConnections->CompSets(Count).InletNodeName != state.dataBranchNodeConnections->CompSets(Other).InletNodeName) {
@@ -2290,8 +2202,11 @@ void TestInletOutletNodes(EnergyPlusData &state)
 
     AlreadyNoted = false;
     for (int Count = 1; Count <= state.dataBranchNodeConnections->NumCompSets; ++Count) {
+        if (state.dataBranchNodeConnections->CompSets(Count).Source != Node::CompSetSource::BranchTopology) {
+            continue;
+        }
         for (int Other = 1; Other <= state.dataBranchNodeConnections->NumCompSets; ++Other) {
-            if (Count == Other) {
+            if (Count == Other || state.dataBranchNodeConnections->CompSets(Other).Source != Node::CompSetSource::BranchTopology) {
                 continue;
             }
             if (state.dataBranchNodeConnections->CompSets(Count).OutletNodeName != state.dataBranchNodeConnections->CompSets(Other).OutletNodeName) {