Repository: NREL/OpenStudio (language: python)

Issue:
E+ 22.1.0: Wrap SetpointManager:SystemNodeReset:Temperature and SetpointManager:SystemNodeReset:Humidity
Enhancement Request
--------------
<!--- Provide a general summary of the feature you would like to see implemented -->

## Detailed Description
<!--- Provide a detailed description of the change or addition you are proposing. Include screenshot/schemas as appropriate -->

## Possible Implementation
<!--- Not mandatory, but if you can, suggest an idea for implementing the feature -->

E+ 22.1.0: Wrap SetpointManager:SystemNodeReset:Temperature and SetpointManager:SystemNodeReset:Humidity
Enhancement Request
--------------
<!--- Provide a general summary of the feature you would like to see implemented -->

## Detailed Description
<!--- Provide a detailed description of the change or addition you are proposing. Include screenshot/schemas as appropriate -->

## Possible Implementation
<!--- Not mandatory, but if you can, suggest an idea for implementing the feature -->



Discussion / hints:
I'm interested in taking this one if it gets into the queue.
I'm interested in taking this one if it gets into the queue.

Fix patch:
diff --git a/developer/ruby/SubProjectClassGenerators/ProjectClassGenerator.rb b/developer/ruby/SubProjectClassGenerators/ProjectClassGenerator.rb
index 09bef07d8bc..f7bc643605a 100644
--- a/developer/ruby/SubProjectClassGenerators/ProjectClassGenerator.rb
+++ b/developer/ruby/SubProjectClassGenerators/ProjectClassGenerator.rb
@@ -198,19 +198,19 @@ def hppPublicTypedefs()
     result = String.new
 
     result << "\n"
-    result << "  typedef detail::" << @className << "_Impl ImplType;\n"
+    result << "  using ImplType = detail::" << @className << "_Impl;\n\n"
     if @joinRecord
-      result << "  typedef JoinRecordColumns ColumnsType;\n\n"
+      result << "  using JoinRecordColumns = ColumnsType;\n\n"
     else
       if @baseClassName == "ObjectRecord"
-        result << "  typedef " << @className << "Columns ColumnsType;\n"
-        result << "  typedef " << @className << " ObjectRecordType;\n\n"
+        result << "  using ColumnsType = " << @className << "Columns;\n"
+        result << "  using ObjectRecordType = " << @className << ";\n\n"
       else
         result << "  // TODO: Check this typedef. The generator script assumes that the hierarchy is only two deep "
         result << "  // from ObjectRecord.\n"
-        result << "  typedef " << @baseClassName << "Columns ColumnsType;\n"
+        result << "  using ColumnsType = " << @baseClassName << "Columns;\n"
         result << "  // TODO: Check this typedef too.\n"
-        result << "  typedef " << @baseClassName << " ObjectRecordType;\n\n"
+        result << "  using ObjectRecordType = " << @baseClassName << ";\n\n"
       end
     end
 
diff --git a/developer/ruby/SubProjectClassGenerators/SubProjectClassGenerator.rb b/developer/ruby/SubProjectClassGenerators/SubProjectClassGenerator.rb
index f2118c992cd..47433a03a7b 100644
--- a/developer/ruby/SubProjectClassGenerators/SubProjectClassGenerator.rb
+++ b/developer/ruby/SubProjectClassGenerators/SubProjectClassGenerator.rb
@@ -199,7 +199,7 @@ def hppProtectedImpl()
     result = String.new
 
     if pImpl
-      result << "  typedef detail::" << className << "_Impl ImplType;\n\n"
+      result << "  using ImplType = detail::" << className << "_Impl;\n\n"
       result << "  explicit " << className << "(std::shared_ptr<detail::" << className << "_Impl> impl);\n\n"
       result << "  friend class detail::" << @className << "_Impl;\n"
     end
@@ -277,9 +277,9 @@ def cppPublicClassPrivateMethods()
   def hppPostClass()
     result = String.new
     result << "/** \\relates " << className << "*/\n"
-    result << "typedef boost::optional<" << className << "> Optional" << className << ";\n\n"
+    result << "using Optional" << className << " = boost::optional<" << className << ">;\n\n"
     result << "/** \\relates " << className << "*/\n"
-    result << "typedef std::vector<" << className << "> " << className << "Vector;\n\n"
+    result << "using " << className << "Vector = std::vector<" << className << ">;\n\n"
     return result
   end
 
diff --git a/developer/ruby/SubProjectClassGenerators/TranslatorGenerator.rb b/developer/ruby/SubProjectClassGenerators/TranslatorGenerator.rb
index 19e8ff62316..604c22c4967 100644
--- a/developer/ruby/SubProjectClassGenerators/TranslatorGenerator.rb
+++ b/developer/ruby/SubProjectClassGenerators/TranslatorGenerator.rb
@@ -306,7 +306,7 @@ def generateForwardTranslateFunction()
 
     # Instantiate the model object
     result << "\n"
-    result << "  // Instantiate an IdfObject of the class to store the values,\n"
+    result << "  // Instantiate an IdfObject of the class to store the values\n"
     result << "  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::" << @iddObjectType.valueName << ", modelObject);\n"
     result << "  // If it doesn't have a name, or if you aren't sure you are going to want to return it\n"
     result << "  // IdfObject idfObject( openstudio::IddObjectType::" << @iddObjectType.valueName << " );\n"
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index d23cfc11d36..276d48a2d31 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -24803,6 +24803,84 @@ OS:SetpointManager:SingleZone:Heating,
        \type object-list
        \object-list Node
 
+OS:SetpointManager:SystemNodeReset:Temperature,
+        \memo This Setpoint Manager is used to place a temperature setpoint on a system node according to the reference (e.g., return) temperature using a reset rule.
+        \memo The temperature setpoint is obtained by retrieving the temperature of the user specified reference system node.
+   A1 , \field Handle
+        \type handle
+        \required-field
+   A2 , \field Name
+        \required-field
+   A3 , \field Control Variable
+        \required-field
+        \type choice
+        \key Temperature
+        \key MaximumTemperature
+        \key MinimumTemperature
+   N1 , \field Setpoint at Low Reference Temperature
+        \type real
+        \units C
+        \required-field
+   N2 , \field Setpoint at High Reference Temperature
+        \type real
+        \units C
+        \required-field
+   N3 , \field Low Reference Temperature
+        \type real
+        \units C
+        \required-field
+   N4 , \field High Reference Temperature
+        \type real
+        \units C
+        \required-field
+   A4 , \field Reference Node Name
+        \note The name of an HVAC system node that gets referenced. This is a required field.
+        \type object-list
+        \object-list Node
+   A5 ; \field Setpoint Node or NodeList Name
+        \note Node(s) at which temperature will be set. This is a required field.
+        \type object-list
+        \object-list Node
+
+OS:SetpointManager:SystemNodeReset:Humidity,
+        \memo This Setpoint Manager is used to place a humidity ratio setpoint on a system node according to the reference (e.g., return) humidity ratio using a reset rule.
+        \memo The humidity ratio setpoint is obtained by retrieving the humidity ratio of the user specified reference system node.
+   A1 , \field Handle
+        \type handle
+        \required-field
+   A2 , \field Name
+        \required-field
+   A3 , \field Control Variable
+        \required-field
+        \type choice
+        \key HumidityRatio
+        \key MaximumHumidityRatio
+        \key MinimumHumidityRatio
+   N1 , \field Setpoint at Low Reference Humidity Ratio
+        \type real
+        \units kgWater/kgDryAir
+        \required-field
+   N2 , \field Setpoint at High Reference Humidity Ratio
+        \type real
+        \units kgWater/kgDryAir
+        \required-field
+   N3 , \field Low Reference Humidity Ratio
+        \type real
+        \units kgWater/kgDryAir
+        \required-field
+   N4 , \field High Reference Humidity Ratio
+        \type real
+        \units kgWater/kgDryAir
+        \required-field
+   A4 , \field Reference Node Name
+        \note The name of an HVAC system node that gets referenced. This is a required field.
+        \type object-list
+        \object-list Node
+   A5 ; \field Setpoint Node or NodeList Name
+        \note Node(s) at which humidity ratio will be set. This is a required field.
+        \type object-list
+        \object-list Node
+
 OS:Sizing:Plant,
   A1, \field Handle
        \type handle
diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt
index eb3822cc8ae..d441f66ca9d 100644
--- a/src/energyplus/CMakeLists.txt
+++ b/src/energyplus/CMakeLists.txt
@@ -336,6 +336,8 @@ set(${target_name}_src
   ForwardTranslator/ForwardTranslateSetpointManagerSingleZoneReheat.cpp
   ForwardTranslator/ForwardTranslateSetpointManagerWarmest.cpp
   ForwardTranslator/ForwardTranslateSetpointManagerWarmestTemperatureFlow.cpp
+  ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetHumidity.cpp
+  ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetTemperature.cpp
   ForwardTranslator/ForwardTranslateShade.cpp
   ForwardTranslator/ForwardTranslateShadowCalculation.cpp
   ForwardTranslator/ForwardTranslateShadingControl.cpp
@@ -552,6 +554,8 @@ set(${target_name}_src
   ReverseTranslator/ReverseTranslateSetpointManagerMixedAir.cpp
   ReverseTranslator/ReverseTranslateSetpointManagerScheduled.cpp
   ReverseTranslator/ReverseTranslateSetpointManagerSingleZoneReheat.cpp
+  ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetHumidity.cpp
+  ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetTemperature.cpp
   ReverseTranslator/ReverseTranslateShadingBuildingDetailed.cpp
   ReverseTranslator/ReverseTranslateShadingSiteDetailed.cpp
   ReverseTranslator/ReverseTranslateShadingZoneDetailed.cpp
@@ -717,6 +721,8 @@ set(${target_name}_test_src
   Test/ScheduleInterval_GTest.cpp
   Test/ScheduleRuleset_GTest.cpp
   Test/SetpointManagerFollowGroundTemperature_GTest.cpp
+  Test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
+  Test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
   Test/ShadingControl_GTest.cpp
   Test/ShadingSurface_GTest.cpp
   Test/ShadowCalculation_GTest.cpp
diff --git a/src/energyplus/ForwardTranslator.cpp b/src/energyplus/ForwardTranslator.cpp
index 1caf909689c..0794cf18f02 100644
--- a/src/energyplus/ForwardTranslator.cpp
+++ b/src/energyplus/ForwardTranslator.cpp
@@ -2658,6 +2658,16 @@ namespace energyplus {
         retVal = translateSetpointManagerWarmestTemperatureFlow(spm);
         break;
       }
+      case openstudio::IddObjectType::OS_SetpointManager_SystemNodeReset_Humidity: {
+        auto spm = modelObject.cast<SetpointManagerSystemNodeResetHumidity>();
+        retVal = translateSetpointManagerSystemNodeResetHumidity(spm);
+        break;
+      }
+      case openstudio::IddObjectType::OS_SetpointManager_SystemNodeReset_Temperature: {
+        auto spm = modelObject.cast<SetpointManagerSystemNodeResetTemperature>();
+        retVal = translateSetpointManagerSystemNodeResetTemperature(spm);
+        break;
+      }
       case openstudio::IddObjectType::OS_ShadingControl: {
         model::ShadingControl shadingControl = modelObject.cast<ShadingControl>();
         retVal = translateShadingControl(shadingControl);
diff --git a/src/energyplus/ForwardTranslator.hpp b/src/energyplus/ForwardTranslator.hpp
index 935b7dd9295..dbbab258906 100644
--- a/src/energyplus/ForwardTranslator.hpp
+++ b/src/energyplus/ForwardTranslator.hpp
@@ -382,6 +382,8 @@ namespace model {
   class SetpointManagerSingleZoneReheat;
   class SetpointManagerWarmest;
   class SetpointManagerWarmestTemperatureFlow;
+  class SetpointManagerSystemNodeResetHumidity;
+  class SetpointManagerSystemNodeResetTemperature;
   class ShadowCalculation;
   class Shade;
   class SimulationControl;
@@ -1308,6 +1310,10 @@ namespace energyplus {
 
     boost::optional<IdfObject> translateSetpointManagerWarmestTemperatureFlow(model::SetpointManagerWarmestTemperatureFlow& modelObject);
 
+    boost::optional<IdfObject> translateSetpointManagerSystemNodeResetHumidity(model::SetpointManagerSystemNodeResetHumidity& modelObject);
+
+    boost::optional<IdfObject> translateSetpointManagerSystemNodeResetTemperature(model::SetpointManagerSystemNodeResetTemperature& modelObject);
+
     boost::optional<IdfObject> translateShade(model::Shade& modelObject);
 
     boost::optional<IdfObject> translateShadingControl(model::ShadingControl& modelObject);
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetHumidity.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetHumidity.cpp
new file mode 100644
index 00000000000..f29607f2ffd
--- /dev/null
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetHumidity.cpp
@@ -0,0 +1,88 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "../ForwardTranslator.hpp"
+#include "../../model/Model.hpp"
+
+#include "../../model/SetpointManagerSystemNodeResetHumidity.hpp"
+
+#include "../../model/Node.hpp"
+
+#include <utilities/idd/SetpointManager_SystemNodeReset_Humidity_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject>
+    ForwardTranslator::translateSetpointManagerSystemNodeResetHumidity(model::SetpointManagerSystemNodeResetHumidity& modelObject) {
+
+    // Translation is triggered via the setpointNode already, so no need to check
+    if (!modelObject.referenceNode()) {
+      LOG(Error, modelObject.briefDescription() << " does not have a Reference Node attached, it will be not be translated.");
+      return boost::none;
+    }
+
+    // Instantiate an IdfObject of the class to store the values
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_SystemNodeReset_Humidity, modelObject);
+
+    // Control Variable: Required String
+    std::string controlVariable = modelObject.controlVariable();
+    idfObject.setString(SetpointManager_SystemNodeReset_HumidityFields::ControlVariable, controlVariable);
+
+    // Setpoint at Low Reference Humidity Ratio: Required Double
+    double setpointatLowReferenceHumidityRatio = modelObject.setpointatLowReferenceHumidityRatio();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatLowReferenceHumidityRatio, setpointatLowReferenceHumidityRatio);
+
+    // Setpoint at High Reference Humidity Ratio: Required Double
+    double setpointatHighReferenceHumidityRatio = modelObject.setpointatHighReferenceHumidityRatio();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatHighReferenceHumidityRatio, setpointatHighReferenceHumidityRatio);
+
+    // Low Reference Humidity Ratio: Required Double
+    double lowReferenceHumidityRatio = modelObject.lowReferenceHumidityRatio();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_HumidityFields::LowReferenceHumidityRatio, lowReferenceHumidityRatio);
+
+    // High Reference Humidity Ratio: Required Double
+    double highReferenceHumidityRatio = modelObject.highReferenceHumidityRatio();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_HumidityFields::HighReferenceHumidityRatio, highReferenceHumidityRatio);
+
+    // Reference Node Name: Required Node (but we checked it above)
+    idfObject.setString(SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName, modelObject.referenceNode()->nameString());
+
+    // Setpoint Node or NodeList Name: Required Node (but we know it exists)
+    idfObject.setString(SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName, modelObject.setpointNode()->nameString());
+
+    return idfObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetTemperature.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetTemperature.cpp
new file mode 100644
index 00000000000..c2fcac599a3
--- /dev/null
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateSetpointManagerSystemNodeResetTemperature.cpp
@@ -0,0 +1,88 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "../ForwardTranslator.hpp"
+#include "../../model/Model.hpp"
+
+#include "../../model/SetpointManagerSystemNodeResetTemperature.hpp"
+
+#include "../../model/Node.hpp"
+
+#include <utilities/idd/SetpointManager_SystemNodeReset_Temperature_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject>
+    ForwardTranslator::translateSetpointManagerSystemNodeResetTemperature(model::SetpointManagerSystemNodeResetTemperature& modelObject) {
+
+    // Translation is triggered via the setpointNode already, so no need to check
+    if (!modelObject.referenceNode()) {
+      LOG(Error, modelObject.briefDescription() << " does not have a Reference Node attached, it will be not be translated.");
+      return boost::none;
+    }
+
+    // Instantiate an IdfObject of the class to store the values
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_SystemNodeReset_Temperature, modelObject);
+
+    // Control Variable: Required String
+    std::string controlVariable = modelObject.controlVariable();
+    idfObject.setString(SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable, controlVariable);
+
+    // Setpoint at Low Reference Temperature: Required Double
+    double setpointatLowReferenceTemperature = modelObject.setpointatLowReferenceTemperature();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatLowReferenceTemperature, setpointatLowReferenceTemperature);
+
+    // Setpoint at High Reference Temperature: Required Double
+    double setpointatHighReferenceTemperature = modelObject.setpointatHighReferenceTemperature();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatHighReferenceTemperature, setpointatHighReferenceTemperature);
+
+    // Low Reference Temperature: Required Double
+    double lowReferenceTemperature = modelObject.lowReferenceTemperature();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_TemperatureFields::LowReferenceTemperature, lowReferenceTemperature);
+
+    // High Reference Temperature: Required Double
+    double highReferenceTemperature = modelObject.highReferenceTemperature();
+    idfObject.setDouble(SetpointManager_SystemNodeReset_TemperatureFields::HighReferenceTemperature, highReferenceTemperature);
+
+    // Reference Node Name: Required Node (but we checked it above)
+    idfObject.setString(SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName, modelObject.referenceNode()->nameString());
+
+    // Setpoint Node or NodeList Name: Required Node (but we know it exists)
+    idfObject.setString(SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName, modelObject.setpointNode()->nameString());
+
+    return idfObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/ReverseTranslator.cpp b/src/energyplus/ReverseTranslator.cpp
index c63f1495694..c077fa8a25f 100644
--- a/src/energyplus/ReverseTranslator.cpp
+++ b/src/energyplus/ReverseTranslator.cpp
@@ -810,6 +810,14 @@ namespace energyplus {
         //modelObject = translateSetpointManagerSingleZoneReheat(workspaceObject);
         break;
       }
+      case openstudio::IddObjectType::SetpointManager_SystemNodeReset_Humidity: {
+        //modelObject = translateSetpointManagerSystemNodeResetHumidity(workspaceObject);
+        break;
+      }
+      case openstudio::IddObjectType::SetpointManager_SystemNodeReset_Temperature: {
+        //modelObject = translateSetpointManagerSystemNodeResetTemperature(workspaceObject);
+        break;
+      }
       case openstudio::IddObjectType::Shading_Building_Detailed: {
         modelObject = translateShadingBuildingDetailed(workspaceObject);
         break;
diff --git a/src/energyplus/ReverseTranslator.hpp b/src/energyplus/ReverseTranslator.hpp
index c88884b6f32..5bd30b202f5 100644
--- a/src/energyplus/ReverseTranslator.hpp
+++ b/src/energyplus/ReverseTranslator.hpp
@@ -315,6 +315,10 @@ namespace energyplus {
 
     boost::optional<model::ModelObject> translateSetpointManagerSingleZoneReheat(const WorkspaceObject& workspaceObject);
 
+    boost::optional<model::ModelObject> translateSetpointManagerSystemNodeResetHumidity(const WorkspaceObject& workspaceObject);
+
+    boost::optional<model::ModelObject> translateSetpointManagerSystemNodeResetTemperature(const WorkspaceObject& workspaceObject);
+
     boost::optional<model::ModelObject> translateShadingBuildingDetailed(const WorkspaceObject& workspaceObject);
 
     boost::optional<model::ModelObject> translateShadingSiteDetailed(const WorkspaceObject& workspaceObject);
diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetHumidity.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetHumidity.cpp
new file mode 100644
index 00000000000..a26d912af45
--- /dev/null
+++ b/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetHumidity.cpp
@@ -0,0 +1,128 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "../ReverseTranslator.hpp"
+
+#include "../../model/SetpointManagerSystemNodeResetHumidity.hpp"
+
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+
+#include <utilities/idd/SetpointManager_SystemNodeReset_Humidity_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<ModelObject> ReverseTranslator::translateSetpointManagerSystemNodeResetHumidity(const WorkspaceObject& workspaceObject) {
+
+    boost::optional<Node> setpointNode;
+    if (boost::optional<std::string> setpointNodeName =
+          workspaceObject.getString(SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName)) {
+      setpointNode = m_model.getModelObjectByName<Node>(setpointNodeName.get());
+    }
+
+    if (!setpointNode) {
+      LOG(Error, workspaceObject.briefDescription() << " is not attached to a Setpoint Node in the model");
+
+      return boost::none;
+    }
+
+    boost::optional<Node> referenceNode;
+    if (boost::optional<std::string> referenceNodeName =
+          workspaceObject.getString(SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName)) {
+      referenceNode = m_model.getModelObjectByName<Node>(referenceNodeName.get());
+    }
+
+    if (!referenceNode) {
+      LOG(Error, workspaceObject.briefDescription() << " is not attached to a Reference Node in the model");
+
+      return boost::none;
+    }
+
+    openstudio::model::SetpointManagerSystemNodeResetHumidity modelObject(m_model);
+
+    // Name
+    if (boost::optional<std::string> _name = workspaceObject.name()) {
+      modelObject.setName(_name.get());
+    }
+
+    // Control Variable: Required String
+    if (boost::optional<std::string> _controlVariable = workspaceObject.getString(SetpointManager_SystemNodeReset_HumidityFields::ControlVariable)) {
+      modelObject.setControlVariable(_controlVariable.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Control Variable'");
+    }
+
+    // Setpoint at Low Reference Humidity Ratio: Required Double
+    if (boost::optional<double> _setpointatLowReferenceHumidityRatio =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatLowReferenceHumidityRatio)) {
+      modelObject.setSetpointatLowReferenceHumidityRatio(_setpointatLowReferenceHumidityRatio.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Setpoint at Low Reference Humidity Ratio'");
+    }
+
+    // Setpoint at High Reference Humidity Ratio: Required Double
+    if (boost::optional<double> _setpointatHighReferenceHumidityRatio =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatHighReferenceHumidityRatio)) {
+      modelObject.setSetpointatHighReferenceHumidityRatio(_setpointatHighReferenceHumidityRatio.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Setpoint at High Reference Humidity Ratio'");
+    }
+
+    // Low Reference Humidity Ratio: Required Double
+    if (boost::optional<double> _lowReferenceHumidityRatio =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_HumidityFields::LowReferenceHumidityRatio)) {
+      modelObject.setLowReferenceHumidityRatio(_lowReferenceHumidityRatio.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Low Reference Humidity Ratio'");
+    }
+
+    // High Reference Humidity Ratio: Required Double
+    if (boost::optional<double> _highReferenceHumidityRatio =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_HumidityFields::HighReferenceHumidityRatio)) {
+      modelObject.setHighReferenceHumidityRatio(_highReferenceHumidityRatio.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'High Reference Humidity Ratio'");
+    }
+
+    // Reference Node Name: Required Node
+    modelObject.setReferenceNode(referenceNode.get());
+
+    // Setpoint Node or NodeList Name: Required Node
+    modelObject.addToNode(setpointNode.get());
+
+    return modelObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetTemperature.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetTemperature.cpp
new file mode 100644
index 00000000000..a5398a50ed3
--- /dev/null
+++ b/src/energyplus/ReverseTranslator/ReverseTranslateSetpointManagerSystemNodeResetTemperature.cpp
@@ -0,0 +1,129 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "../ReverseTranslator.hpp"
+
+#include "../../model/SetpointManagerSystemNodeResetTemperature.hpp"
+
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+
+#include <utilities/idd/SetpointManager_SystemNodeReset_Temperature_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<ModelObject> ReverseTranslator::translateSetpointManagerSystemNodeResetTemperature(const WorkspaceObject& workspaceObject) {
+
+    boost::optional<Node> setpointNode;
+    if (boost::optional<std::string> setpointNodeName =
+          workspaceObject.getString(SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName)) {
+      setpointNode = m_model.getModelObjectByName<Node>(setpointNodeName.get());
+    }
+
+    if (!setpointNode) {
+      LOG(Error, workspaceObject.briefDescription() << " is not attached to a Setpoint Node in the model");
+
+      return boost::none;
+    }
+
+    boost::optional<Node> referenceNode;
+    if (boost::optional<std::string> referenceNodeName =
+          workspaceObject.getString(SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName)) {
+      referenceNode = m_model.getModelObjectByName<Node>(referenceNodeName.get());
+    }
+
+    if (!referenceNode) {
+      LOG(Error, workspaceObject.briefDescription() << " is not attached to a Reference Node in the model");
+
+      return boost::none;
+    }
+
+    openstudio::model::SetpointManagerSystemNodeResetTemperature modelObject(m_model);
+
+    // Name
+    if (boost::optional<std::string> _name = workspaceObject.name()) {
+      modelObject.setName(_name.get());
+    }
+
+    // Control Variable: Required String
+    if (boost::optional<std::string> _controlVariable =
+          workspaceObject.getString(SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable)) {
+      modelObject.setControlVariable(_controlVariable.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Control Variable'");
+    }
+
+    // Setpoint at Low Reference Temperature: Required Double
+    if (boost::optional<double> _setpointatLowReferenceTemperature =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatLowReferenceTemperature)) {
+      modelObject.setSetpointatLowReferenceTemperature(_setpointatLowReferenceTemperature.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Setpoint at Low Reference Temperature'");
+    }
+
+    // Setpoint at High Reference Temperature: Required Double
+    if (boost::optional<double> _setpointatHighReferenceTemperature =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatHighReferenceTemperature)) {
+      modelObject.setSetpointatHighReferenceTemperature(_setpointatHighReferenceTemperature.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Setpoint at High Reference Temperature'");
+    }
+
+    // Low Reference Temperature: Required Double
+    if (boost::optional<double> _lowReferenceTemperature =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::LowReferenceTemperature)) {
+      modelObject.setLowReferenceTemperature(_lowReferenceTemperature.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'Low Reference Temperature'");
+    }
+
+    // High Reference Temperature: Required Double
+    if (boost::optional<double> _highReferenceTemperature =
+          workspaceObject.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::HighReferenceTemperature)) {
+      modelObject.setHighReferenceTemperature(_highReferenceTemperature.get());
+    } else {
+      LOG(Warn, "For " << workspaceObject.briefDescription() << ", cannot find required property 'High Reference Temperature'");
+    }
+
+    // Reference Node Name: Required Node
+    modelObject.setReferenceNode(referenceNode.get());
+
+    // Setpoint Node or NodeList Name: Required Node
+    modelObject.addToNode(setpointNode.get());
+
+    return modelObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/Test/SetpointManagerSystemNodeResetHumidity_GTest.cpp b/src/energyplus/Test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
new file mode 100644
index 00000000000..6dee480d2b1
--- /dev/null
+++ b/src/energyplus/Test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
@@ -0,0 +1,89 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include <gtest/gtest.h>
+#include "EnergyPlusFixture.hpp"
+
+#include "../ForwardTranslator.hpp"
+#include "../ReverseTranslator.hpp"
+
+#include "../../model/Model.hpp"
+#include "../../model/SetpointManagerSystemNodeResetHumidity.hpp"
+#include "../../model/SetpointManagerSystemNodeResetHumidity_Impl.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/AirLoopHVAC.hpp"
+#include "../../model/PlantLoop.hpp"
+
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/SetpointManager_SystemNodeReset_Humidity_FieldEnums.hxx>
+
+#include <resources.hxx>
+
+#include <sstream>
+
+using namespace openstudio::energyplus;
+using namespace openstudio::model;
+using namespace openstudio;
+
+TEST_F(EnergyPlusFixture, ForwardTranslator_SetpointManagerSystemNodeResetHumidity) {
+  Model m;
+  AirLoopHVAC airloop(m);
+  Node supplyOutlet = airloop.supplyOutletNode();
+  supplyOutlet.setName("Supply Outlet Node");
+  Node supplyInlet = airloop.supplyInletNode();
+  supplyInlet.setName("Supply Inlet Node");
+
+  SetpointManagerSystemNodeResetHumidity spm(m);
+
+  EXPECT_TRUE(spm.setControlVariable("MinimumHumidityRatio"));
+  EXPECT_TRUE(spm.setSetpointatLowReferenceHumidityRatio(0.002));
+  EXPECT_TRUE(spm.setSetpointatHighReferenceHumidityRatio(0.001));
+  EXPECT_TRUE(spm.setLowReferenceHumidityRatio(0.004));
+  EXPECT_TRUE(spm.setHighReferenceHumidityRatio(0.003));
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+  EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+
+  ForwardTranslator forwardTranslator;
+  Workspace workspace = forwardTranslator.translateModel(m);
+  EXPECT_EQ(0u, forwardTranslator.errors().size());
+
+  WorkspaceObjectVector spmIdfs = workspace.getObjectsByType(IddObjectType::SetpointManager_SystemNodeReset_Humidity);
+  ASSERT_EQ(1u, spmIdfs.size());
+  auto& spmIdf = spmIdfs.front();
+
+  EXPECT_EQ(spm.nameString(), spmIdf.nameString());
+  EXPECT_EQ("MinimumHumidityRatio", spmIdf.getString(SetpointManager_SystemNodeReset_HumidityFields::ControlVariable).get());
+  EXPECT_EQ(0.002, spmIdf.getDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatLowReferenceHumidityRatio).get());
+  EXPECT_EQ(0.001, spmIdf.getDouble(SetpointManager_SystemNodeReset_HumidityFields::SetpointatHighReferenceHumidityRatio).get());
+  EXPECT_EQ(0.004, spmIdf.getDouble(SetpointManager_SystemNodeReset_HumidityFields::LowReferenceHumidityRatio).get());
+  EXPECT_EQ(0.003, spmIdf.getDouble(SetpointManager_SystemNodeReset_HumidityFields::HighReferenceHumidityRatio).get());
+  EXPECT_EQ("Supply Inlet Node", spmIdf.getString(SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName).get());
+  EXPECT_EQ("Supply Outlet Node", spmIdf.getString(SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName).get());
+}
diff --git a/src/energyplus/Test/SetpointManagerSystemNodeResetTemperature_GTest.cpp b/src/energyplus/Test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
new file mode 100644
index 00000000000..154c59261ff
--- /dev/null
+++ b/src/energyplus/Test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
@@ -0,0 +1,89 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include <gtest/gtest.h>
+#include "EnergyPlusFixture.hpp"
+
+#include "../ForwardTranslator.hpp"
+#include "../ReverseTranslator.hpp"
+
+#include "../../model/Model.hpp"
+#include "../../model/SetpointManagerSystemNodeResetTemperature.hpp"
+#include "../../model/SetpointManagerSystemNodeResetTemperature_Impl.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/AirLoopHVAC.hpp"
+#include "../../model/PlantLoop.hpp"
+
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/SetpointManager_SystemNodeReset_Temperature_FieldEnums.hxx>
+
+#include <resources.hxx>
+
+#include <sstream>
+
+using namespace openstudio::energyplus;
+using namespace openstudio::model;
+using namespace openstudio;
+
+TEST_F(EnergyPlusFixture, ForwardTranslator_SetpointManagerSystemNodeResetTemperature) {
+  Model m;
+  AirLoopHVAC airloop(m);
+  Node supplyOutlet = airloop.supplyOutletNode();
+  supplyOutlet.setName("Supply Outlet Node");
+  Node supplyInlet = airloop.supplyInletNode();
+  supplyInlet.setName("Supply Inlet Node");
+
+  SetpointManagerSystemNodeResetTemperature spm(m);
+
+  EXPECT_TRUE(spm.setControlVariable("MinimumTemperature"));
+  EXPECT_TRUE(spm.setSetpointatLowReferenceTemperature(80.0));
+  EXPECT_TRUE(spm.setSetpointatHighReferenceTemperature(60.0));
+  EXPECT_TRUE(spm.setLowReferenceTemperature(-10.0));
+  EXPECT_TRUE(spm.setHighReferenceTemperature(10.0));
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+  EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+
+  ForwardTranslator forwardTranslator;
+  Workspace workspace = forwardTranslator.translateModel(m);
+  EXPECT_EQ(0u, forwardTranslator.errors().size());
+
+  WorkspaceObjectVector spmIdfs = workspace.getObjectsByType(IddObjectType::SetpointManager_SystemNodeReset_Temperature);
+  ASSERT_EQ(1u, spmIdfs.size());
+  auto& spmIdf = spmIdfs.front();
+
+  EXPECT_EQ(spm.nameString(), spmIdf.nameString());
+  EXPECT_EQ("MinimumTemperature", spmIdf.getString(SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable).get());
+  EXPECT_EQ(80.0, spmIdf.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatLowReferenceTemperature).get());
+  EXPECT_EQ(60.0, spmIdf.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::SetpointatHighReferenceTemperature).get());
+  EXPECT_EQ(-10.0, spmIdf.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::LowReferenceTemperature).get());
+  EXPECT_EQ(10.0, spmIdf.getDouble(SetpointManager_SystemNodeReset_TemperatureFields::HighReferenceTemperature).get());
+  EXPECT_EQ("Supply Inlet Node", spmIdf.getString(SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName).get());
+  EXPECT_EQ("Supply Outlet Node", spmIdf.getString(SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName).get());
+}
diff --git a/src/model/CMakeLists.txt b/src/model/CMakeLists.txt
index 360f01f7666..699e6d4fc1e 100644
--- a/src/model/CMakeLists.txt
+++ b/src/model/CMakeLists.txt
@@ -1352,6 +1352,12 @@ set(${target_name}_src
   SetpointManagerWarmestTemperatureFlow.hpp
   SetpointManagerWarmestTemperatureFlow_Impl.hpp
   SetpointManagerWarmestTemperatureFlow.cpp
+  SetpointManagerSystemNodeResetHumidity.hpp
+  SetpointManagerSystemNodeResetHumidity_Impl.hpp
+  SetpointManagerSystemNodeResetHumidity.cpp
+  SetpointManagerSystemNodeResetTemperature.hpp
+  SetpointManagerSystemNodeResetTemperature_Impl.hpp
+  SetpointManagerSystemNodeResetTemperature.cpp
   Shade.hpp
   Shade_Impl.hpp
   Shade.cpp
@@ -2148,6 +2154,8 @@ set(${target_name}_test_src
   test/SetpointManagerSingleZoneHeating_GTest.cpp
   test/SetpointManagerWarmest_GTest.cpp
   test/SetpointManagerWarmestTemperatureFlow_GTest.cpp
+  test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
+  test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
   test/ScheduleDay_GTest.cpp
   test/ScheduleInterval_GTest.cpp
   test/ScheduleRuleset_GTest.cpp
diff --git a/src/model/ConcreteModelObjects.hpp b/src/model/ConcreteModelObjects.hpp
index 14665687b75..3808ce7089d 100644
--- a/src/model/ConcreteModelObjects.hpp
+++ b/src/model/ConcreteModelObjects.hpp
@@ -435,6 +435,8 @@
 #include "SetpointManagerSingleZoneReheat.hpp"
 #include "SetpointManagerWarmest.hpp"
 #include "SetpointManagerWarmestTemperatureFlow.hpp"
+#include "SetpointManagerSystemNodeResetHumidity.hpp"
+#include "SetpointManagerSystemNodeResetTemperature.hpp"
 #include "Shade.hpp"
 #include "ShadingControl.hpp"
 #include "ShadingSurface.hpp"
@@ -956,6 +958,8 @@
 #include "SetpointManagerSingleZoneReheat_Impl.hpp"
 #include "SetpointManagerWarmest_Impl.hpp"
 #include "SetpointManagerWarmestTemperatureFlow_Impl.hpp"
+#include "SetpointManagerSystemNodeResetHumidity_Impl.hpp"
+#include "SetpointManagerSystemNodeResetTemperature_Impl.hpp"
 #include "Shade_Impl.hpp"
 #include "ShadingControl_Impl.hpp"
 #include "ShadingSurface_Impl.hpp"
diff --git a/src/model/Model.cpp b/src/model/Model.cpp
index 34ab01b5ff8..958a7cb8226 100644
--- a/src/model/Model.cpp
+++ b/src/model/Model.cpp
@@ -4132,6 +4132,8 @@ namespace model {
     REGISTER_CONSTRUCTOR(SetpointManagerSingleZoneReheat);
     REGISTER_CONSTRUCTOR(SetpointManagerWarmest);
     REGISTER_CONSTRUCTOR(SetpointManagerWarmestTemperatureFlow);
+    REGISTER_CONSTRUCTOR(SetpointManagerSystemNodeResetHumidity);
+    REGISTER_CONSTRUCTOR(SetpointManagerSystemNodeResetTemperature);
     REGISTER_CONSTRUCTOR(Shade);
     REGISTER_CONSTRUCTOR(ShadingControl);
     REGISTER_CONSTRUCTOR(ShadingSurface);
@@ -4661,6 +4663,8 @@ namespace model {
     REGISTER_COPYCONSTRUCTORS(SetpointManagerSingleZoneReheat);
     REGISTER_COPYCONSTRUCTORS(SetpointManagerWarmest);
     REGISTER_COPYCONSTRUCTORS(SetpointManagerWarmestTemperatureFlow);
+    REGISTER_COPYCONSTRUCTORS(SetpointManagerSystemNodeResetHumidity);
+    REGISTER_COPYCONSTRUCTORS(SetpointManagerSystemNodeResetTemperature);
     REGISTER_COPYCONSTRUCTORS(Shade);
     REGISTER_COPYCONSTRUCTORS(ShadingControl);
     REGISTER_COPYCONSTRUCTORS(ShadingSurface);
diff --git a/src/model/ModelHVAC.i b/src/model/ModelHVAC.i
index 9080626f4dc..91590c33ddd 100644
--- a/src/model/ModelHVAC.i
+++ b/src/model/ModelHVAC.i
@@ -236,6 +236,8 @@ MODELOBJECT_TEMPLATES(SetpointManagerWarmest);
 MODELOBJECT_TEMPLATES(SetpointManagerWarmestTemperatureFlow);
 MODELOBJECT_TEMPLATES(SetpointManagerColdest);
 MODELOBJECT_TEMPLATES(SetpointManagerFollowGroundTemperature);
+MODELOBJECT_TEMPLATES(SetpointManagerSystemNodeResetHumidity);
+MODELOBJECT_TEMPLATES(SetpointManagerSystemNodeResetTemperature);
 
 SWIG_MODELOBJECT(PortList, 1);
 SWIG_MODELOBJECT(Loop, 0);
@@ -355,6 +357,8 @@ SWIG_MODELOBJECT(SetpointManagerWarmest,1);
 SWIG_MODELOBJECT(SetpointManagerWarmestTemperatureFlow,1);
 SWIG_MODELOBJECT(SetpointManagerColdest,1);
 SWIG_MODELOBJECT(SetpointManagerFollowGroundTemperature,1);
+SWIG_MODELOBJECT(SetpointManagerSystemNodeResetHumidity,1);
+SWIG_MODELOBJECT(SetpointManagerSystemNodeResetTemperature,1);
 
 #if defined(SWIGCSHARP) || defined(SWIGJAVA)
   %inline {
diff --git a/src/model/SetpointManagerSystemNodeResetHumidity.cpp b/src/model/SetpointManagerSystemNodeResetHumidity.cpp
new file mode 100644
index 00000000000..b9072e3cf00
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetHumidity.cpp
@@ -0,0 +1,257 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "SetpointManagerSystemNodeResetHumidity.hpp"
+#include "SetpointManagerSystemNodeResetHumidity_Impl.hpp"
+
+#include "Node.hpp"
+#include "Node_Impl.hpp"
+#include "PlantLoop.hpp"
+#include "Model.hpp"
+
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/OS_SetpointManager_SystemNodeReset_Humidity_FieldEnums.hxx>
+
+#include "../utilities/core/Assert.hpp"
+
+namespace openstudio {
+namespace model {
+
+  namespace detail {
+
+    SetpointManagerSystemNodeResetHumidity_Impl::SetpointManagerSystemNodeResetHumidity_Impl(const IdfObject& idfObject, Model_Impl* model,
+                                                                                             bool keepHandle)
+      : SetpointManager_Impl(idfObject, model, keepHandle) {
+      OS_ASSERT(idfObject.iddObject().type() == SetpointManagerSystemNodeResetHumidity::iddObjectType());
+    }
+
+    SetpointManagerSystemNodeResetHumidity_Impl::SetpointManagerSystemNodeResetHumidity_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
+                                                                                             Model_Impl* model, bool keepHandle)
+      : SetpointManager_Impl(other, model, keepHandle) {
+      OS_ASSERT(other.iddObject().type() == SetpointManagerSystemNodeResetHumidity::iddObjectType());
+    }
+
+    SetpointManagerSystemNodeResetHumidity_Impl::SetpointManagerSystemNodeResetHumidity_Impl(const SetpointManagerSystemNodeResetHumidity_Impl& other,
+                                                                                             Model_Impl* model, bool keepHandle)
+      : SetpointManager_Impl(other, model, keepHandle) {}
+
+    const std::vector<std::string>& SetpointManagerSystemNodeResetHumidity_Impl::outputVariableNames() const {
+      static std::vector<std::string> result;
+      if (result.empty()) {
+      }
+      return result;
+    }
+
+    IddObjectType SetpointManagerSystemNodeResetHumidity_Impl::iddObjectType() const {
+      return SetpointManagerSystemNodeResetHumidity::iddObjectType();
+    }
+
+    /** This SPM is **NOT** allowed on a PlantLoop */
+    bool SetpointManagerSystemNodeResetHumidity_Impl::isAllowedOnPlantLoop() const {
+      return false;
+    }
+
+    ModelObject SetpointManagerSystemNodeResetHumidity_Impl::clone(Model model) const {
+      auto clonedObject = SetpointManager_Impl::clone(model).cast<SetpointManagerSystemNodeResetHumidity>();
+      clonedObject.resetReferenceNode();
+      return clonedObject;
+    }
+
+    std::string SetpointManagerSystemNodeResetHumidity_Impl::controlVariable() const {
+      boost::optional<std::string> value = getString(OS_SetpointManager_SystemNodeReset_HumidityFields::ControlVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetHumidity_Impl::setpointatLowReferenceHumidityRatio() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointatLowReferenceHumidityRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetHumidity_Impl::setpointatHighReferenceHumidityRatio() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointatHighReferenceHumidityRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetHumidity_Impl::lowReferenceHumidityRatio() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::LowReferenceHumidityRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetHumidity_Impl::highReferenceHumidityRatio() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::HighReferenceHumidityRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Node> SetpointManagerSystemNodeResetHumidity_Impl::referenceNode() const {
+      return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName);
+    }
+
+    boost::optional<Node> SetpointManagerSystemNodeResetHumidity_Impl::setpointNode() const {
+      return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName);
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setControlVariable(const std::string& controlVariable) {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_HumidityFields::ControlVariable, controlVariable);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setSetpointatLowReferenceHumidityRatio(double setpointatLowReferenceHumidityRatio) {
+      bool result =
+        setDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointatLowReferenceHumidityRatio, setpointatLowReferenceHumidityRatio);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setSetpointatHighReferenceHumidityRatio(double setpointatHighReferenceHumidityRatio) {
+      bool result =
+        setDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointatHighReferenceHumidityRatio, setpointatHighReferenceHumidityRatio);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setLowReferenceHumidityRatio(double lowReferenceHumidityRatio) {
+      bool result = setDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::LowReferenceHumidityRatio, lowReferenceHumidityRatio);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setHighReferenceHumidityRatio(double highReferenceHumidityRatio) {
+      bool result = setDouble(OS_SetpointManager_SystemNodeReset_HumidityFields::HighReferenceHumidityRatio, highReferenceHumidityRatio);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setReferenceNode(const Node& node) {
+      if (node.plantLoop()) {
+        LOG(Error, "Cannot set the Reference node to a node that is on a PlantLoop, occurred for " << briefDescription());
+        return false;
+      }
+      bool result = setPointer(OS_SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName, node.handle());
+      return result;
+    }
+
+    void SetpointManagerSystemNodeResetHumidity_Impl::resetReferenceNode() {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_HumidityFields::ReferenceNodeName, "");
+      OS_ASSERT(result);
+    }
+
+    bool SetpointManagerSystemNodeResetHumidity_Impl::setSetpointNode(const Node& node) {
+      bool result = setPointer(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName, node.handle());
+      return result;
+    }
+
+    void SetpointManagerSystemNodeResetHumidity_Impl::resetSetpointNode() {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_HumidityFields::SetpointNodeorNodeListName, "");
+      OS_ASSERT(result);
+    }
+
+  }  // namespace detail
+
+  SetpointManagerSystemNodeResetHumidity::SetpointManagerSystemNodeResetHumidity(const Model& model)
+    : SetpointManager(SetpointManagerSystemNodeResetHumidity::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>());
+
+    // From E+ 5ZoneSystemNodeReset.idf (22.1.0)
+    bool ok = setControlVariable("MaximumHumidityRatio");
+    OS_ASSERT(ok);
+    setSetpointatLowReferenceHumidityRatio(0.00924);
+    setSetpointatHighReferenceHumidityRatio(0.00600);
+    setLowReferenceHumidityRatio(0.00850);
+    setHighReferenceHumidityRatio(0.01000);
+  }
+
+  IddObjectType SetpointManagerSystemNodeResetHumidity::iddObjectType() {
+    return IddObjectType(IddObjectType::OS_SetpointManager_SystemNodeReset_Humidity);
+  }
+
+  std::vector<std::string> SetpointManagerSystemNodeResetHumidity::controlVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_SetpointManager_SystemNodeReset_HumidityFields::ControlVariable);
+  }
+
+  double SetpointManagerSystemNodeResetHumidity::setpointatLowReferenceHumidityRatio() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setpointatLowReferenceHumidityRatio();
+  }
+
+  double SetpointManagerSystemNodeResetHumidity::setpointatHighReferenceHumidityRatio() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setpointatHighReferenceHumidityRatio();
+  }
+
+  double SetpointManagerSystemNodeResetHumidity::lowReferenceHumidityRatio() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->lowReferenceHumidityRatio();
+  }
+
+  double SetpointManagerSystemNodeResetHumidity::highReferenceHumidityRatio() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->highReferenceHumidityRatio();
+  }
+
+  boost::optional<Node> SetpointManagerSystemNodeResetHumidity::referenceNode() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->referenceNode();
+  }
+
+  bool SetpointManagerSystemNodeResetHumidity::setSetpointatLowReferenceHumidityRatio(double setpointatLowReferenceHumidityRatio) {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setSetpointatLowReferenceHumidityRatio(
+      setpointatLowReferenceHumidityRatio);
+  }
+
+  bool SetpointManagerSystemNodeResetHumidity::setSetpointatHighReferenceHumidityRatio(double setpointatHighReferenceHumidityRatio) {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setSetpointatHighReferenceHumidityRatio(
+      setpointatHighReferenceHumidityRatio);
+  }
+
+  bool SetpointManagerSystemNodeResetHumidity::setLowReferenceHumidityRatio(double lowReferenceHumidityRatio) {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setLowReferenceHumidityRatio(lowReferenceHumidityRatio);
+  }
+
+  bool SetpointManagerSystemNodeResetHumidity::setHighReferenceHumidityRatio(double highReferenceHumidityRatio) {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setHighReferenceHumidityRatio(highReferenceHumidityRatio);
+  }
+
+  bool SetpointManagerSystemNodeResetHumidity::setReferenceNode(const Node& node) {
+    return getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->setReferenceNode(node);
+  }
+
+  void SetpointManagerSystemNodeResetHumidity::resetReferenceNode() {
+    getImpl<detail::SetpointManagerSystemNodeResetHumidity_Impl>()->resetReferenceNode();
+  }
+
+  /// @cond
+  SetpointManagerSystemNodeResetHumidity::SetpointManagerSystemNodeResetHumidity(
+    std::shared_ptr<detail::SetpointManagerSystemNodeResetHumidity_Impl> impl)
+    : SetpointManager(impl) {}
+  /// @endcond
+
+}  // namespace model
+}  // namespace openstudio
diff --git a/src/model/SetpointManagerSystemNodeResetHumidity.hpp b/src/model/SetpointManagerSystemNodeResetHumidity.hpp
new file mode 100644
index 00000000000..09a81cfc6c4
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetHumidity.hpp
@@ -0,0 +1,123 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#ifndef MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_HPP
+#define MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_HPP
+
+#include "ModelAPI.hpp"
+#include "SetpointManager.hpp"
+
+namespace openstudio {
+
+namespace model {
+
+  class Node;
+
+  namespace detail {
+
+    class SetpointManagerSystemNodeResetHumidity_Impl;
+
+  }  // namespace detail
+
+  /** SetpointManagerSystemNodeResetHumidity is a SetpointManager that wraps the OpenStudio IDD object 'OS:SetpointManager:SystemNodeReset:Humidity'. */
+  class MODEL_API SetpointManagerSystemNodeResetHumidity : public SetpointManager
+  {
+   public:
+    /** @name Constructors and Destructors */
+    //@{
+
+    explicit SetpointManagerSystemNodeResetHumidity(const Model& model);
+
+    virtual ~SetpointManagerSystemNodeResetHumidity() {}
+
+    //@}
+
+    static IddObjectType iddObjectType();
+
+    static std::vector<std::string> controlVariableValues();
+
+    /** @name Getters */
+    //@{
+
+    double setpointatLowReferenceHumidityRatio() const;
+
+    double setpointatHighReferenceHumidityRatio() const;
+
+    double lowReferenceHumidityRatio() const;
+
+    double highReferenceHumidityRatio() const;
+
+    boost::optional<Node> referenceNode() const;
+
+    //@}
+    /** @name Setters */
+    //@{
+
+    bool setSetpointatLowReferenceHumidityRatio(double setpointatLowReferenceHumidityRatio);
+
+    bool setSetpointatHighReferenceHumidityRatio(double setpointatHighReferenceHumidityRatio);
+
+    bool setLowReferenceHumidityRatio(double lowReferenceHumidityRatio);
+
+    bool setHighReferenceHumidityRatio(double highReferenceHumidityRatio);
+
+    bool setReferenceNode(const Node& node);
+
+    void resetReferenceNode();
+
+    //@}
+    /** @name Other */
+    //@{
+
+    //@}
+   protected:
+    /// @cond
+    using ImplType = detail::SetpointManagerSystemNodeResetHumidity_Impl;
+
+    explicit SetpointManagerSystemNodeResetHumidity(std::shared_ptr<detail::SetpointManagerSystemNodeResetHumidity_Impl> impl);
+
+    friend class detail::SetpointManagerSystemNodeResetHumidity_Impl;
+    friend class Model;
+    friend class IdfObject;
+    friend class openstudio::detail::IdfObject_Impl;
+    /// @endcond
+   private:
+    REGISTER_LOGGER("openstudio.model.SetpointManagerSystemNodeResetHumidity");
+  };
+
+  /** \relates SetpointManagerSystemNodeResetHumidity*/
+  using OptionalSetpointManagerSystemNodeResetHumidity = boost::optional<SetpointManagerSystemNodeResetHumidity>;
+
+  /** \relates SetpointManagerSystemNodeResetHumidity*/
+  using SetpointManagerSystemNodeResetHumidityVector = std::vector<SetpointManagerSystemNodeResetHumidity>;
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_HPP
diff --git a/src/model/SetpointManagerSystemNodeResetHumidity_Impl.hpp b/src/model/SetpointManagerSystemNodeResetHumidity_Impl.hpp
new file mode 100644
index 00000000000..e79ab2553e2
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetHumidity_Impl.hpp
@@ -0,0 +1,124 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#ifndef MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_IMPL_HPP
+#define MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_IMPL_HPP
+
+#include "ModelAPI.hpp"
+#include "SetpointManager_Impl.hpp"
+
+namespace openstudio {
+namespace model {
+
+  class Node;
+
+  namespace detail {
+
+    /** SetpointManagerSystemNodeResetHumidity_Impl is a SetpointManager_Impl that is the implementation class for SetpointManagerSystemNodeResetHumidity.*/
+    class MODEL_API SetpointManagerSystemNodeResetHumidity_Impl : public SetpointManager_Impl
+    {
+     public:
+      /** @name Constructors and Destructors */
+      //@{
+
+      SetpointManagerSystemNodeResetHumidity_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle);
+
+      SetpointManagerSystemNodeResetHumidity_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle);
+
+      SetpointManagerSystemNodeResetHumidity_Impl(const SetpointManagerSystemNodeResetHumidity_Impl& other, Model_Impl* model, bool keepHandle);
+
+      virtual ~SetpointManagerSystemNodeResetHumidity_Impl() {}
+
+      //@}
+      /** @name Virtual Methods */
+      //@{
+
+      virtual const std::vector<std::string>& outputVariableNames() const override;
+
+      virtual IddObjectType iddObjectType() const override;
+
+      virtual bool isAllowedOnPlantLoop() const override;
+
+      virtual ModelObject clone(Model model) const override;
+
+      virtual std::string controlVariable() const override;
+
+      virtual bool setControlVariable(const std::string& controlVariable) override;
+
+      virtual boost::optional<Node> setpointNode() const override;
+
+      virtual bool setSetpointNode(const Node& node) override;
+
+      virtual void resetSetpointNode() override;
+
+      //@}
+      /** @name Getters */
+      //@{
+
+      double setpointatLowReferenceHumidityRatio() const;
+
+      double setpointatHighReferenceHumidityRatio() const;
+
+      double lowReferenceHumidityRatio() const;
+
+      double highReferenceHumidityRatio() const;
+
+      boost::optional<Node> referenceNode() const;
+
+      //@}
+      /** @name Setters */
+      //@{
+
+      bool setSetpointatLowReferenceHumidityRatio(double setpointatLowReferenceHumidityRatio);
+
+      bool setSetpointatHighReferenceHumidityRatio(double setpointatHighReferenceHumidityRatio);
+
+      bool setLowReferenceHumidityRatio(double lowReferenceHumidityRatio);
+
+      bool setHighReferenceHumidityRatio(double highReferenceHumidityRatio);
+
+      bool setReferenceNode(const Node& node);
+      void resetReferenceNode();
+
+      //@}
+      /** @name Other */
+      //@{
+
+      //@}
+     protected:
+     private:
+      REGISTER_LOGGER("openstudio.model.SetpointManagerSystemNodeResetHumidity");
+    };
+
+  }  // namespace detail
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_SETPOINTMANAGERSYSTEMNODERESETHUMIDITY_IMPL_HPP
diff --git a/src/model/SetpointManagerSystemNodeResetTemperature.cpp b/src/model/SetpointManagerSystemNodeResetTemperature.cpp
new file mode 100644
index 00000000000..29a4496beab
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetTemperature.cpp
@@ -0,0 +1,254 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "SetpointManagerSystemNodeResetTemperature.hpp"
+#include "SetpointManagerSystemNodeResetTemperature_Impl.hpp"
+
+#include "Node.hpp"
+#include "Node_Impl.hpp"
+#include "PlantLoop.hpp"
+#include "Model.hpp"
+
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/OS_SetpointManager_SystemNodeReset_Temperature_FieldEnums.hxx>
+
+#include "../utilities/units/Unit.hpp"
+
+#include "../utilities/core/Assert.hpp"
+
+namespace openstudio {
+namespace model {
+
+  namespace detail {
+
+    SetpointManagerSystemNodeResetTemperature_Impl::SetpointManagerSystemNodeResetTemperature_Impl(const IdfObject& idfObject, Model_Impl* model,
+                                                                                                   bool keepHandle)
+      : SetpointManager_Impl(idfObject, model, keepHandle) {
+      OS_ASSERT(idfObject.iddObject().type() == SetpointManagerSystemNodeResetTemperature::iddObjectType());
+    }
+
+    SetpointManagerSystemNodeResetTemperature_Impl::SetpointManagerSystemNodeResetTemperature_Impl(
+      const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
+      : SetpointManager_Impl(other, model, keepHandle) {
+      OS_ASSERT(other.iddObject().type() == SetpointManagerSystemNodeResetTemperature::iddObjectType());
+    }
+
+    SetpointManagerSystemNodeResetTemperature_Impl::SetpointManagerSystemNodeResetTemperature_Impl(
+      const SetpointManagerSystemNodeResetTemperature_Impl& other, Model_Impl* model, bool keepHandle)
+      : SetpointManager_Impl(other, model, keepHandle) {}
+
+    const std::vector<std::string>& SetpointManagerSystemNodeResetTemperature_Impl::outputVariableNames() const {
+      static std::vector<std::string> result;
+      if (result.empty()) {
+      }
+      return result;
+    }
+
+    IddObjectType SetpointManagerSystemNodeResetTemperature_Impl::iddObjectType() const {
+      return SetpointManagerSystemNodeResetTemperature::iddObjectType();
+    }
+
+    /** This SPM **IS** allowed on a PlantLoop */
+    bool SetpointManagerSystemNodeResetTemperature_Impl::isAllowedOnPlantLoop() const {
+      return true;
+    }
+
+    ModelObject SetpointManagerSystemNodeResetTemperature_Impl::clone(Model model) const {
+      auto clonedObject = SetpointManager_Impl::clone(model).cast<SetpointManagerSystemNodeResetTemperature>();
+      clonedObject.resetReferenceNode();
+      return clonedObject;
+    }
+
+    std::string SetpointManagerSystemNodeResetTemperature_Impl::controlVariable() const {
+      boost::optional<std::string> value = getString(OS_SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetTemperature_Impl::setpointatLowReferenceTemperature() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointatLowReferenceTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetTemperature_Impl::setpointatHighReferenceTemperature() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointatHighReferenceTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetTemperature_Impl::lowReferenceTemperature() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::LowReferenceTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double SetpointManagerSystemNodeResetTemperature_Impl::highReferenceTemperature() const {
+      boost::optional<double> value = getDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::HighReferenceTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Node> SetpointManagerSystemNodeResetTemperature_Impl::referenceNode() const {
+      return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName);
+    }
+
+    boost::optional<Node> SetpointManagerSystemNodeResetTemperature_Impl::setpointNode() const {
+      return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName);
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setControlVariable(const std::string& controlVariable) {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable, controlVariable);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setSetpointatLowReferenceTemperature(double setpointatLowReferenceTemperature) {
+      bool result =
+        setDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointatLowReferenceTemperature, setpointatLowReferenceTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setSetpointatHighReferenceTemperature(double setpointatHighReferenceTemperature) {
+      bool result =
+        setDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointatHighReferenceTemperature, setpointatHighReferenceTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setLowReferenceTemperature(double lowReferenceTemperature) {
+      bool result = setDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::LowReferenceTemperature, lowReferenceTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setHighReferenceTemperature(double highReferenceTemperature) {
+      bool result = setDouble(OS_SetpointManager_SystemNodeReset_TemperatureFields::HighReferenceTemperature, highReferenceTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setReferenceNode(const Node& node) {
+      bool result = setPointer(OS_SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName, node.handle());
+      return result;
+    }
+
+    void SetpointManagerSystemNodeResetTemperature_Impl::resetReferenceNode() {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_TemperatureFields::ReferenceNodeName, "");
+      OS_ASSERT(result);
+    }
+
+    bool SetpointManagerSystemNodeResetTemperature_Impl::setSetpointNode(const Node& node) {
+      bool result = setPointer(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName, node.handle());
+      return result;
+    }
+
+    void SetpointManagerSystemNodeResetTemperature_Impl::resetSetpointNode() {
+      bool result = setString(OS_SetpointManager_SystemNodeReset_TemperatureFields::SetpointNodeorNodeListName, "");
+      OS_ASSERT(result);
+    }
+
+  }  // namespace detail
+
+  SetpointManagerSystemNodeResetTemperature::SetpointManagerSystemNodeResetTemperature(const Model& model)
+    : SetpointManager(SetpointManagerSystemNodeResetTemperature::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>());
+
+    // From E+ 5ZoneSystemNodeReset.idf (22.1.0)
+    bool ok = setControlVariable("Temperature");
+    OS_ASSERT(ok);
+    setSetpointatLowReferenceTemperature(16.7);
+    setSetpointatHighReferenceTemperature(12.8);
+    setLowReferenceTemperature(20.0);
+    setHighReferenceTemperature(23.3);
+  }
+
+  IddObjectType SetpointManagerSystemNodeResetTemperature::iddObjectType() {
+    return IddObjectType(IddObjectType::OS_SetpointManager_SystemNodeReset_Temperature);
+  }
+
+  std::vector<std::string> SetpointManagerSystemNodeResetTemperature::controlVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_SetpointManager_SystemNodeReset_TemperatureFields::ControlVariable);
+  }
+
+  double SetpointManagerSystemNodeResetTemperature::setpointatLowReferenceTemperature() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setpointatLowReferenceTemperature();
+  }
+
+  double SetpointManagerSystemNodeResetTemperature::setpointatHighReferenceTemperature() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setpointatHighReferenceTemperature();
+  }
+
+  double SetpointManagerSystemNodeResetTemperature::lowReferenceTemperature() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->lowReferenceTemperature();
+  }
+
+  double SetpointManagerSystemNodeResetTemperature::highReferenceTemperature() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->highReferenceTemperature();
+  }
+
+  boost::optional<Node> SetpointManagerSystemNodeResetTemperature::referenceNode() const {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->referenceNode();
+  }
+
+  bool SetpointManagerSystemNodeResetTemperature::setSetpointatLowReferenceTemperature(double setpointatLowReferenceTemperature) {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setSetpointatLowReferenceTemperature(setpointatLowReferenceTemperature);
+  }
+
+  bool SetpointManagerSystemNodeResetTemperature::setSetpointatHighReferenceTemperature(double setpointatHighReferenceTemperature) {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setSetpointatHighReferenceTemperature(
+      setpointatHighReferenceTemperature);
+  }
+
+  bool SetpointManagerSystemNodeResetTemperature::setLowReferenceTemperature(double lowReferenceTemperature) {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setLowReferenceTemperature(lowReferenceTemperature);
+  }
+
+  bool SetpointManagerSystemNodeResetTemperature::setHighReferenceTemperature(double highReferenceTemperature) {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setHighReferenceTemperature(highReferenceTemperature);
+  }
+
+  bool SetpointManagerSystemNodeResetTemperature::setReferenceNode(const Node& node) {
+    return getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->setReferenceNode(node);
+  }
+
+  void SetpointManagerSystemNodeResetTemperature::resetReferenceNode() {
+    getImpl<detail::SetpointManagerSystemNodeResetTemperature_Impl>()->resetReferenceNode();
+  }
+
+  /// @cond
+  SetpointManagerSystemNodeResetTemperature::SetpointManagerSystemNodeResetTemperature(
+    std::shared_ptr<detail::SetpointManagerSystemNodeResetTemperature_Impl> impl)
+    : SetpointManager(impl) {}
+  /// @endcond
+
+}  // namespace model
+}  // namespace openstudio
diff --git a/src/model/SetpointManagerSystemNodeResetTemperature.hpp b/src/model/SetpointManagerSystemNodeResetTemperature.hpp
new file mode 100644
index 00000000000..ecbbb6b1309
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetTemperature.hpp
@@ -0,0 +1,123 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#ifndef MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_HPP
+#define MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_HPP
+
+#include "ModelAPI.hpp"
+#include "SetpointManager.hpp"
+
+namespace openstudio {
+
+namespace model {
+
+  class Node;
+
+  namespace detail {
+
+    class SetpointManagerSystemNodeResetTemperature_Impl;
+
+  }  // namespace detail
+
+  /** SetpointManagerSystemNodeResetTemperature is a SetpointManager that wraps the OpenStudio IDD object 'OS:SetpointManager:SystemNodeReset:Temperature'. */
+  class MODEL_API SetpointManagerSystemNodeResetTemperature : public SetpointManager
+  {
+   public:
+    /** @name Constructors and Destructors */
+    //@{
+
+    explicit SetpointManagerSystemNodeResetTemperature(const Model& model);
+
+    virtual ~SetpointManagerSystemNodeResetTemperature() {}
+
+    //@}
+
+    static IddObjectType iddObjectType();
+
+    static std::vector<std::string> controlVariableValues();
+
+    /** @name Getters */
+    //@{
+
+    double setpointatLowReferenceTemperature() const;
+
+    double setpointatHighReferenceTemperature() const;
+
+    double lowReferenceTemperature() const;
+
+    double highReferenceTemperature() const;
+
+    boost::optional<Node> referenceNode() const;
+
+    //@}
+    /** @name Setters */
+    //@{
+
+    bool setSetpointatLowReferenceTemperature(double setpointatLowReferenceTemperature);
+
+    bool setSetpointatHighReferenceTemperature(double setpointatHighReferenceTemperature);
+
+    bool setLowReferenceTemperature(double lowReferenceTemperature);
+
+    bool setHighReferenceTemperature(double highReferenceTemperature);
+
+    bool setReferenceNode(const Node& node);
+
+    void resetReferenceNode();
+
+    //@}
+    /** @name Other */
+    //@{
+
+    //@}
+   protected:
+    /// @cond
+    using ImplType = detail::SetpointManagerSystemNodeResetTemperature_Impl;
+
+    explicit SetpointManagerSystemNodeResetTemperature(std::shared_ptr<detail::SetpointManagerSystemNodeResetTemperature_Impl> impl);
+
+    friend class detail::SetpointManagerSystemNodeResetTemperature_Impl;
+    friend class Model;
+    friend class IdfObject;
+    friend class openstudio::detail::IdfObject_Impl;
+    /// @endcond
+   private:
+    REGISTER_LOGGER("openstudio.model.SetpointManagerSystemNodeResetTemperature");
+  };
+
+  /** \relates SetpointManagerSystemNodeResetTemperature*/
+  using OptionalSetpointManagerSystemNodeResetTemperature = boost::optional<SetpointManagerSystemNodeResetTemperature>;
+
+  /** \relates SetpointManagerSystemNodeResetTemperature*/
+  using SetpointManagerSystemNodeResetTemperatureVector = std::vector<SetpointManagerSystemNodeResetTemperature>;
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_HPP
diff --git a/src/model/SetpointManagerSystemNodeResetTemperature_Impl.hpp b/src/model/SetpointManagerSystemNodeResetTemperature_Impl.hpp
new file mode 100644
index 00000000000..eb26d140159
--- /dev/null
+++ b/src/model/SetpointManagerSystemNodeResetTemperature_Impl.hpp
@@ -0,0 +1,125 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#ifndef MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_IMPL_HPP
+#define MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_IMPL_HPP
+
+#include "ModelAPI.hpp"
+#include "SetpointManager_Impl.hpp"
+
+namespace openstudio {
+namespace model {
+
+  class Node;
+
+  namespace detail {
+
+    /** SetpointManagerSystemNodeResetTemperature_Impl is a SetpointManager_Impl that is the implementation class for SetpointManagerSystemNodeResetTemperature.*/
+    class MODEL_API SetpointManagerSystemNodeResetTemperature_Impl : public SetpointManager_Impl
+    {
+     public:
+      /** @name Constructors and Destructors */
+      //@{
+
+      SetpointManagerSystemNodeResetTemperature_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle);
+
+      SetpointManagerSystemNodeResetTemperature_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle);
+
+      SetpointManagerSystemNodeResetTemperature_Impl(const SetpointManagerSystemNodeResetTemperature_Impl& other, Model_Impl* model, bool keepHandle);
+
+      virtual ~SetpointManagerSystemNodeResetTemperature_Impl() {}
+
+      //@}
+      /** @name Virtual Methods */
+      //@{
+
+      virtual const std::vector<std::string>& outputVariableNames() const override;
+
+      virtual IddObjectType iddObjectType() const override;
+
+      virtual bool isAllowedOnPlantLoop() const override;
+
+      virtual ModelObject clone(Model model) const override;
+
+      virtual std::string controlVariable() const override;
+
+      virtual bool setControlVariable(const std::string& controlVariable) override;
+
+      virtual boost::optional<Node> setpointNode() const override;
+
+      virtual bool setSetpointNode(const Node& node) override;
+
+      virtual void resetSetpointNode() override;
+
+      //@}
+      /** @name Getters */
+      //@{
+
+      double setpointatLowReferenceTemperature() const;
+
+      double setpointatHighReferenceTemperature() const;
+
+      double lowReferenceTemperature() const;
+
+      double highReferenceTemperature() const;
+
+      boost::optional<Node> referenceNode() const;
+
+      //@}
+      /** @name Setters */
+      //@{
+
+      bool setSetpointatLowReferenceTemperature(double setpointatLowReferenceTemperature);
+
+      bool setSetpointatHighReferenceTemperature(double setpointatHighReferenceTemperature);
+
+      bool setLowReferenceTemperature(double lowReferenceTemperature);
+
+      bool setHighReferenceTemperature(double highReferenceTemperature);
+
+      bool setReferenceNode(const Node& node);
+
+      void resetReferenceNode();
+
+      //@}
+      /** @name Other */
+      //@{
+
+      //@}
+     protected:
+     private:
+      REGISTER_LOGGER("openstudio.model.SetpointManagerSystemNodeResetTemperature");
+    };
+
+  }  // namespace detail
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_SETPOINTMANAGERSYSTEMNODERESETTEMPERATURE_IMPL_HPP


Test patch:
diff --git a/src/model/test/SetpointManagerSystemNodeResetHumidity_GTest.cpp b/src/model/test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
new file mode 100644
index 00000000000..fc8ec205180
--- /dev/null
+++ b/src/model/test/SetpointManagerSystemNodeResetHumidity_GTest.cpp
@@ -0,0 +1,206 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include <gtest/gtest.h>
+
+#include "ModelFixture.hpp"
+
+#include "../SetpointManagerSystemNodeResetHumidity.hpp"
+#include "../SetpointManagerSystemNodeResetHumidity_Impl.hpp"
+
+#include "../Model.hpp"
+#include "../Node.hpp"
+#include "../AirLoopHVAC.hpp"
+#include "../PlantLoop.hpp"
+
+using namespace openstudio;
+using namespace openstudio::model;
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetHumidity_GettersSetters) {
+  Model m;
+  SetpointManagerSystemNodeResetHumidity spm(m);
+
+  spm.setName("My SetpointManagerSystemNodeResetHumidity");
+
+  // Control Variable: Required String
+  EXPECT_TRUE(spm.setControlVariable("HumidityRatio"));
+  EXPECT_EQ("HumidityRatio", spm.controlVariable());
+  // Bad Value
+  EXPECT_FALSE(spm.setControlVariable("BADENUM"));
+  EXPECT_EQ("HumidityRatio", spm.controlVariable());
+
+  // Setpoint at Low Reference Humidity Ratio: Required Double
+  EXPECT_TRUE(spm.setSetpointatLowReferenceHumidityRatio(0.4));
+  EXPECT_EQ(0.4, spm.setpointatLowReferenceHumidityRatio());
+
+  // Setpoint at High Reference Humidity Ratio: Required Double
+  EXPECT_TRUE(spm.setSetpointatHighReferenceHumidityRatio(0.5));
+  EXPECT_EQ(0.5, spm.setpointatHighReferenceHumidityRatio());
+
+  // Low Reference Humidity Ratio: Required Double
+  EXPECT_TRUE(spm.setLowReferenceHumidityRatio(0.6));
+  EXPECT_EQ(0.6, spm.lowReferenceHumidityRatio());
+
+  // High Reference Humidity Ratio: Required Double
+  EXPECT_TRUE(spm.setHighReferenceHumidityRatio(0.7));
+  EXPECT_EQ(0.7, spm.highReferenceHumidityRatio());
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetHumidity_addToNode) {
+
+  Model m;
+
+  // AirLoopHVAC
+  {
+    SetpointManagerSystemNodeResetHumidity spm(m);
+    AirLoopHVAC a(m);
+    Node supplyOutlet = a.supplyOutletNode();
+    Node supplyInlet = a.supplyInletNode();
+    Node demandInlet = a.demandInletNode();
+
+    EXPECT_FALSE(spm.setpointNode());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_FALSE(spm.addToNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_TRUE(spm.setReferenceNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(demandInlet, spm.referenceNode().get());
+
+    EXPECT_TRUE(spm.setControlVariable("MinimumHumidityRatio"));
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm, supplyOutlet.setpointManagers().front());
+
+    // Add a SPM with the same control variable => the first one is removed
+    SetpointManagerSystemNodeResetHumidity spm2(m);
+    EXPECT_TRUE(spm2.setControlVariable("MinimumHumidityRatio"));
+    EXPECT_TRUE(spm2.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm2.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm2.setpointNode().get());
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm2, supplyOutlet.setpointManagers().front());
+
+    SetpointManagerSystemNodeResetHumidity spm3(m);
+    EXPECT_TRUE(spm3.setControlVariable("MaximumHumidityRatio"));
+    EXPECT_TRUE(spm3.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm3.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm3.setpointNode().get());
+    ASSERT_EQ(2, supplyOutlet.setpointManagers().size());
+  }
+
+  // PlantLoop: **NOT** allowed
+  {
+    SetpointManagerSystemNodeResetHumidity spm(m);
+    PlantLoop p(m);
+    Node supplyOutlet = p.supplyOutletNode();
+    Node supplyInlet = p.supplyInletNode();
+    Node demandInlet = p.demandInletNode();
+    std::vector<Node> testNodes{supplyOutlet, supplyInlet, demandInlet};
+
+    EXPECT_FALSE(spm.setpointNode());
+    EXPECT_FALSE(spm.referenceNode());
+
+    for (auto& node : testNodes) {
+      EXPECT_FALSE(spm.addToNode(node));
+      EXPECT_FALSE(spm.setReferenceNode(node));
+
+      EXPECT_FALSE(spm.setpointNode());
+      EXPECT_FALSE(spm.referenceNode());
+    }
+  }
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetHumidity_remove) {
+  Model m;
+  AirLoopHVAC a(m);
+  Node supplyOutlet = a.supplyOutletNode();
+
+  SetpointManagerSystemNodeResetHumidity spm(m);
+
+  EXPECT_TRUE(spm.setControlVariable("MinimumHumidityRatio"));
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+
+  EXPECT_EQ(1, supplyOutlet.setpointManagers().size());
+  EXPECT_EQ(1, m.getModelObjects<SetpointManagerSystemNodeResetHumidity>().size());
+
+  spm.remove();
+
+  EXPECT_EQ(0, supplyOutlet.setpointManagers().size());
+  EXPECT_EQ(0, m.getModelObjects<SetpointManagerSystemNodeResetHumidity>().size());
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetHumidity_clone) {
+  Model m;
+  AirLoopHVAC a(m);
+  Node supplyOutlet = a.supplyOutletNode();
+  Node supplyInlet = a.supplyInletNode();
+
+  SetpointManagerSystemNodeResetHumidity spm(m);
+
+  EXPECT_TRUE(spm.setControlVariable("MinimumHumidityRatio"));
+  EXPECT_TRUE(spm.setSetpointatLowReferenceHumidityRatio(0.002));
+  EXPECT_TRUE(spm.setSetpointatHighReferenceHumidityRatio(0.001));
+  EXPECT_TRUE(spm.setLowReferenceHumidityRatio(0.004));
+  EXPECT_TRUE(spm.setHighReferenceHumidityRatio(0.003));
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+  EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+  ASSERT_TRUE(spm.setpointNode());
+  EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+  ASSERT_TRUE(spm.referenceNode());
+  EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+  auto spmClone = spm.clone(m).cast<SetpointManagerSystemNodeResetHumidity>();
+  EXPECT_FALSE(spmClone.setpointNode());
+  EXPECT_FALSE(spmClone.referenceNode());
+
+  EXPECT_EQ(spm.controlVariable(), spmClone.controlVariable());
+  EXPECT_EQ(spm.setpointatLowReferenceHumidityRatio(), spmClone.setpointatLowReferenceHumidityRatio());
+  EXPECT_EQ(spm.setpointatHighReferenceHumidityRatio(), spmClone.setpointatHighReferenceHumidityRatio());
+  EXPECT_EQ(spm.lowReferenceHumidityRatio(), spmClone.lowReferenceHumidityRatio());
+  EXPECT_EQ(spm.highReferenceHumidityRatio(), spmClone.highReferenceHumidityRatio());
+}
diff --git a/src/model/test/SetpointManagerSystemNodeResetTemperature_GTest.cpp b/src/model/test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
new file mode 100644
index 00000000000..27730e92dce
--- /dev/null
+++ b/src/model/test/SetpointManagerSystemNodeResetTemperature_GTest.cpp
@@ -0,0 +1,248 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include <gtest/gtest.h>
+
+#include "ModelFixture.hpp"
+
+#include "../SetpointManagerSystemNodeResetTemperature.hpp"
+#include "../SetpointManagerSystemNodeResetTemperature_Impl.hpp"
+
+#include "../Model.hpp"
+#include "../Node.hpp"
+#include "../Node_Impl.hpp"
+#include "../AirLoopHVAC.hpp"
+#include "../PlantLoop.hpp"
+#include "../CoilHeatingWater.hpp"
+
+#include "ModelFixture.hpp"
+
+using namespace openstudio;
+using namespace openstudio::model;
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetTemperature_GettersSetters) {
+  Model m;
+  SetpointManagerSystemNodeResetTemperature spm(m);
+  // TODO: Or if a UniqueModelObject (and make sure _Impl is included)
+  // SetpointManagerSystemNodeResetTemperature spm = m.getUniqueModelObject<SetpointManagerSystemNodeResetTemperature>();
+
+  spm.setName("My SetpointManagerSystemNodeResetTemperature");
+
+  // Control Variable: Required String
+  EXPECT_TRUE(spm.setControlVariable("Temperature"));
+  EXPECT_EQ("Temperature", spm.controlVariable());
+  // Bad Value
+  EXPECT_FALSE(spm.setControlVariable("BADENUM"));
+  EXPECT_EQ("Temperature", spm.controlVariable());
+
+  // Setpoint at Low Reference Temperature: Required Double
+  EXPECT_TRUE(spm.setSetpointatLowReferenceTemperature(0.4));
+  EXPECT_EQ(0.4, spm.setpointatLowReferenceTemperature());
+
+  // Setpoint at High Reference Temperature: Required Double
+  EXPECT_TRUE(spm.setSetpointatHighReferenceTemperature(0.5));
+  EXPECT_EQ(0.5, spm.setpointatHighReferenceTemperature());
+
+  // Low Reference Temperature: Required Double
+  EXPECT_TRUE(spm.setLowReferenceTemperature(0.6));
+  EXPECT_EQ(0.6, spm.lowReferenceTemperature());
+
+  // High Reference Temperature: Required Double
+  EXPECT_TRUE(spm.setHighReferenceTemperature(0.7));
+  EXPECT_EQ(0.7, spm.highReferenceTemperature());
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetTemperature_addToNode) {
+
+  Model m;
+
+  // AirLoopHVAC
+  {
+    SetpointManagerSystemNodeResetTemperature spm(m);
+    AirLoopHVAC a(m);
+    Node supplyOutlet = a.supplyOutletNode();
+    Node supplyInlet = a.supplyInletNode();
+    Node demandInlet = a.demandInletNode();
+
+    EXPECT_FALSE(spm.setpointNode());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_FALSE(spm.addToNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_TRUE(spm.setReferenceNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(demandInlet, spm.referenceNode().get());
+
+    spm.setControlVariable("MinimumTemperature");
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm, supplyOutlet.setpointManagers().front());
+
+    // Add a SPM with the same control variable => the first one is removed
+    SetpointManagerSystemNodeResetTemperature spm2(m);
+    spm2.setControlVariable("MinimumTemperature");
+    EXPECT_TRUE(spm2.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm2.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm2.setpointNode().get());
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm2, supplyOutlet.setpointManagers().front());
+
+    SetpointManagerSystemNodeResetTemperature spm3(m);
+    EXPECT_TRUE(spm3.setControlVariable("MaximumTemperature"));
+    EXPECT_TRUE(spm3.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm3.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm3.setpointNode().get());
+    ASSERT_EQ(2, supplyOutlet.setpointManagers().size());
+  }
+
+  // PlantLoop: allowed
+  {
+    SetpointManagerSystemNodeResetTemperature spm(m);
+    PlantLoop p(m);
+    Node supplyOutlet = p.supplyOutletNode();
+    Node supplyInlet = p.supplyInletNode();
+
+    // The SPM is allowed on the demand side if that node isn't on a branch
+    CoilHeatingWater c(m);
+    p.addDemandBranchForComponent(c);
+    Node demandInlet = c.waterInletModelObject()->cast<Node>();
+
+    EXPECT_FALSE(spm.setpointNode());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    EXPECT_FALSE(spm.referenceNode());
+
+    EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_FALSE(spm.addToNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+    EXPECT_TRUE(spm.setReferenceNode(demandInlet));
+    ASSERT_TRUE(spm.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+    ASSERT_TRUE(spm.referenceNode());
+    EXPECT_EQ(demandInlet, spm.referenceNode().get());
+
+    spm.setControlVariable("MinimumTemperature");
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm, supplyOutlet.setpointManagers().front());
+
+    // Add a SPM with the same control variable => the first one is removed
+    SetpointManagerSystemNodeResetTemperature spm2(m);
+    spm2.setControlVariable("MinimumTemperature");
+    EXPECT_TRUE(spm2.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm2.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm2.setpointNode().get());
+    ASSERT_EQ(1, supplyOutlet.setpointManagers().size());
+    EXPECT_EQ(spm2, supplyOutlet.setpointManagers().front());
+
+    SetpointManagerSystemNodeResetTemperature spm3(m);
+    EXPECT_TRUE(spm3.setControlVariable("MaximumTemperature"));
+    EXPECT_TRUE(spm3.addToNode(supplyOutlet));
+    ASSERT_TRUE(spm3.setpointNode());
+    EXPECT_EQ(supplyOutlet, spm3.setpointNode().get());
+    ASSERT_EQ(2, supplyOutlet.setpointManagers().size());
+  }
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetTemperature_remove) {
+  Model m;
+  AirLoopHVAC a(m);
+  Node supplyOutlet = a.supplyOutletNode();
+
+  SetpointManagerSystemNodeResetTemperature spm(m);
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+
+  EXPECT_EQ(1, supplyOutlet.setpointManagers().size());
+  EXPECT_EQ(1, m.getModelObjects<SetpointManagerSystemNodeResetTemperature>().size());
+
+  spm.remove();
+
+  EXPECT_EQ(0, supplyOutlet.setpointManagers().size());
+  EXPECT_EQ(0, m.getModelObjects<SetpointManagerSystemNodeResetTemperature>().size());
+}
+
+TEST_F(ModelFixture, SetpointManagerSystemNodeResetTemperature_clone) {
+  Model m;
+  AirLoopHVAC a(m);
+  Node supplyOutlet = a.supplyOutletNode();
+  Node supplyInlet = a.supplyInletNode();
+
+  SetpointManagerSystemNodeResetTemperature spm(m);
+
+  EXPECT_TRUE(spm.setControlVariable("MinimumTemperature"));
+  EXPECT_TRUE(spm.setSetpointatLowReferenceTemperature(80.0));
+  EXPECT_TRUE(spm.setSetpointatHighReferenceTemperature(60.0));
+  EXPECT_TRUE(spm.setLowReferenceTemperature(-10.0));
+  EXPECT_TRUE(spm.setHighReferenceTemperature(10.0));
+
+  EXPECT_TRUE(spm.addToNode(supplyOutlet));
+  EXPECT_TRUE(spm.setReferenceNode(supplyInlet));
+  ASSERT_TRUE(spm.setpointNode());
+  EXPECT_EQ(supplyOutlet, spm.setpointNode().get());
+  ASSERT_TRUE(spm.referenceNode());
+  EXPECT_EQ(supplyInlet, spm.referenceNode().get());
+
+  auto spmClone = spm.clone(m).cast<SetpointManagerSystemNodeResetTemperature>();
+  EXPECT_FALSE(spmClone.setpointNode());
+  EXPECT_FALSE(spmClone.referenceNode());
+
+  EXPECT_EQ(spm.controlVariable(), spmClone.controlVariable());
+  EXPECT_EQ(spm.setpointatLowReferenceTemperature(), spmClone.setpointatLowReferenceTemperature());
+  EXPECT_EQ(spm.setpointatHighReferenceTemperature(), spmClone.setpointatHighReferenceTemperature());
+  EXPECT_EQ(spm.lowReferenceTemperature(), spmClone.lowReferenceTemperature());
+  EXPECT_EQ(spm.highReferenceTemperature(), spmClone.highReferenceTemperature());
+}