diff --git a/pid/stepwisecontroller.cpp b/pid/stepwisecontroller.cpp
index d141f87..b93c349 100644
--- a/pid/stepwisecontroller.cpp
+++ b/pid/stepwisecontroller.cpp
@@ -75,7 +75,6 @@
     if (inputs.empty())
     {
         throw ControllerBuildException("Stepwise controller missing inputs");
-        return nullptr;
     }
 
     auto thermal = std::make_unique<StepwiseController>(id, inputs, owner);
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index 8778719..db4763f 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -30,13 +30,26 @@
 
 ThermalType getThermalType(const std::string& typeString)
 {
-    /* Currently it only supports the two types. */
-    return (typeString == "temp") ? ThermalType::absolute : ThermalType::margin;
+    if (typeString == "margin")
+    {
+        return ThermalType::margin;
+    }
+    if ((typeString == "temp") || (typeString == "power"))
+    {
+        return ThermalType::absolute;
+    }
+    if (typeString == "powersum")
+    {
+        return ThermalType::summation;
+    }
+
+    throw ControllerBuildException("Unrecognized PID Type/Class string");
 }
 
 bool isThermalType(const std::string& typeString)
 {
-    static const std::vector<std::string> thermalTypes = {"temp", "margin"};
+    static const std::vector<std::string> thermalTypes = {"temp", "margin",
+                                                          "power", "powersum"};
     return std::count(thermalTypes.begin(), thermalTypes.end(), typeString);
 }
 
@@ -49,7 +62,6 @@
     if (inputs.empty())
     {
         throw ControllerBuildException("Thermal controller missing inputs");
-        return nullptr;
     }
 
     auto thermal = std::make_unique<ThermalController>(id, inputs, type, owner);
@@ -67,16 +79,27 @@
 {
     double value;
     const double& (*compare)(const double&, const double&);
+    bool doSummation = false;
+
     if (type == ThermalType::margin)
     {
         value = std::numeric_limits<double>::max();
         compare = std::min<double>;
     }
-    else
+    else if (type == ThermalType::absolute)
     {
         value = std::numeric_limits<double>::lowest();
         compare = std::max<double>;
     }
+    else if (type == ThermalType::summation)
+    {
+        doSummation = true;
+        value = 0.0;
+    }
+    else
+    {
+        throw ControllerBuildException("Unrecognized ThermalType");
+    }
 
     bool acceptable = false;
     for (const auto& in : _inputs)
@@ -89,7 +112,15 @@
             continue;
         }
 
-        value = compare(value, cachedValue);
+        if (doSummation)
+        {
+            value += cachedValue;
+        }
+        else
+        {
+            value = compare(value, cachedValue);
+        }
+
         acceptable = true;
     }
 
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
index 6144d49..752c105 100644
--- a/pid/thermalcontroller.hpp
+++ b/pid/thermalcontroller.hpp
@@ -13,12 +13,16 @@
 /*
  * A ThermalController is a PID controller that reads a number of sensors and
  * provides the setpoints for the fans.
+ * With addition of support for power sensors, this name is misleading,
+ * as it now works for power sensors also, not just thermal sensors.
+ * If rewritten today, a better name would be "ComputationType".
  */
 
 enum class ThermalType
 {
     margin,
-    absolute
+    absolute,
+    summation
 };
 
 /**