diff --git a/pid/builder.cpp b/pid/builder.cpp
index 45838e7..8ffa77c 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -16,15 +16,15 @@
 
 #include "pid/builder.hpp"
 
+#include "conf.hpp"
+#include "pid/fancontroller.hpp"
+#include "pid/thermalcontroller.hpp"
+
 #include <iostream>
 #include <memory>
 #include <sdbusplus/bus.hpp>
 #include <unordered_map>
 
-#include "conf.hpp"
-#include "pid/fancontroller.hpp"
-#include "pid/thermalcontroller.hpp"
-
 static constexpr bool deferSignals = true;
 static constexpr auto objectPath = "/xyz/openbmc_project/settings/fanctrl/zone";
 
@@ -33,11 +33,10 @@
     return std::string(objectPath) + std::to_string(zone);
 }
 
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZones(
-        std::map<int64_t, PIDConf>& zonePids,
-        std::map<int64_t, struct zone>& zoneConfigs,
-        SensorManager& mgr,
-        sdbusplus::bus::bus& modeControlBus)
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+    BuildZones(std::map<int64_t, PIDConf>& zonePids,
+               std::map<int64_t, struct zone>& zoneConfigs, SensorManager& mgr,
+               sdbusplus::bus::bus& modeControlBus)
 {
     std::unordered_map<int64_t, std::unique_ptr<PIDZone>> zones;
 
@@ -62,13 +61,9 @@
         PIDConf& PIDConfig = zi.second;
 
         auto zone = std::make_unique<PIDZone>(
-                        zoneId,
-                        zoneConf->second.minthermalrpm,
-                        zoneConf->second.failsafepercent,
-                        mgr,
-                        modeControlBus,
-                        GetControlPath(zi.first).c_str(),
-                        deferSignals);
+            zoneId, zoneConf->second.minthermalrpm,
+            zoneConf->second.failsafepercent, mgr, modeControlBus,
+            GetControlPath(zi.first).c_str(), deferSignals);
 
         std::cerr << "Zone Id: " << zone->getZoneId() << "\n";
 
@@ -93,11 +88,8 @@
                     zone->addFanInput(i);
                 }
 
-                auto pid = FanController::CreateFanPid(
-                               zone.get(),
-                               name,
-                               inputs,
-                               info->info);
+                auto pid = FanController::CreateFanPid(zone.get(), name, inputs,
+                                                       info->info);
                 zone->addFanPID(std::move(pid));
             }
             else if (info->type == "temp" || info->type == "margin")
@@ -109,11 +101,7 @@
                 }
 
                 auto pid = ThermalController::CreateThermalPid(
-                               zone.get(),
-                               name,
-                               inputs,
-                               info->setpoint,
-                               info->info);
+                    zone.get(), name, inputs, info->setpoint, info->info);
                 zone->addThermalPID(std::move(pid));
             }
 
diff --git a/pid/builder.hpp b/pid/builder.hpp
index 5c03bd1..9201b9a 100644
--- a/pid/builder.hpp
+++ b/pid/builder.hpp
@@ -1,14 +1,13 @@
 #pragma once
 
+#include "pid/zone.hpp"
+#include "sensors/manager.hpp"
+
 #include <memory>
 #include <sdbusplus/bus.hpp>
 #include <unordered_map>
 
-#include "pid/zone.hpp"
-#include "sensors/manager.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZones(
-        std::map<int64_t, PIDConf>& zonePids,
-        std::map<int64_t, struct zone>& zoneConfigs,
-        SensorManager& mgr,
-        sdbusplus::bus::bus& modeControlBus);
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+    BuildZones(std::map<int64_t, PIDConf>& zonePids,
+               std::map<int64_t, struct zone>& zoneConfigs, SensorManager& mgr,
+               sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/builderconfig.cpp b/pid/builderconfig.cpp
index 33301e2..0106057 100644
--- a/pid/builderconfig.cpp
+++ b/pid/builderconfig.cpp
@@ -16,6 +16,9 @@
 
 #include "pid/builderconfig.hpp"
 
+#include "conf.hpp"
+#include "pid/builder.hpp"
+
 #include <fstream>
 #include <iostream>
 #include <libconfig.h++>
@@ -24,13 +27,9 @@
 #include <string>
 #include <unordered_map>
 
-#include "conf.hpp"
-#include "pid/builder.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZonesFromConfig(
-        const std::string& path,
-        SensorManager& mgr,
-        sdbusplus::bus::bus& modeControlBus)
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+    BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+                         sdbusplus::bus::bus& modeControlBus)
 {
     using namespace libconfig;
     // zone -> pids
@@ -77,10 +76,9 @@
 
             zoneSettings.lookupValue("id", id);
 
-            thisZoneConfig.minthermalrpm =
-                    zoneSettings.lookup("minthermalrpm");
+            thisZoneConfig.minthermalrpm = zoneSettings.lookup("minthermalrpm");
             thisZoneConfig.failsafepercent =
-                    zoneSettings.lookup("failsafepercent");
+                zoneSettings.lookup("failsafepercent");
 
             const Setting& pids = zoneSettings["pids"];
             int pidCount = pids.getLength();
@@ -136,7 +134,7 @@
             zoneConfig[static_cast<int64_t>(id)] = thisZoneConfig;
         }
     }
-    catch (const SettingTypeException &setex)
+    catch (const SettingTypeException& setex)
     {
         std::cerr << "Setting '" << setex.getPath() << "' type exception!"
                   << std::endl;
diff --git a/pid/builderconfig.hpp b/pid/builderconfig.hpp
index ad83932..a7f41f8 100644
--- a/pid/builderconfig.hpp
+++ b/pid/builderconfig.hpp
@@ -1,14 +1,13 @@
 #pragma once
 
+#include "pid/zone.hpp"
+#include "sensors/manager.hpp"
+
 #include <memory>
 #include <sdbusplus/bus.hpp>
 #include <string>
 #include <unordered_map>
 
-#include "pid/zone.hpp"
-#include "sensors/manager.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZonesFromConfig(
-        const std::string& path,
-        SensorManager& mgr,
-        sdbusplus::bus::bus& modeControlBus);
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+    BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+                         sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/controller.cpp b/pid/controller.cpp
index a5360fe..138268b 100644
--- a/pid/controller.cpp
+++ b/pid/controller.cpp
@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 
+#include "controller.hpp"
+
+#include "ec/pid.hpp"
+
 #include <algorithm>
 #include <chrono>
 #include <iostream>
@@ -22,10 +26,6 @@
 #include <thread>
 #include <vector>
 
-#include "controller.hpp"
-#include "ec/pid.hpp"
-
-
 void PIDController::pid_process(void)
 {
     float input;
diff --git a/pid/controller.hpp b/pid/controller.hpp
index 4220e07..57ee43f 100644
--- a/pid/controller.hpp
+++ b/pid/controller.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
+#include "ec/pid.hpp"
+#include "fan.hpp"
+
 #include <memory>
 #include <vector>
 
-#include "fan.hpp"
-#include "ec/pid.hpp"
-
 class ZoneInterface;
 
 /*
@@ -14,46 +14,46 @@
  */
 class PIDController
 {
-    public:
-        PIDController(const std::string& id, ZoneInterface* owner)
-            : _owner(owner),
-              _setpoint(0),
-              _id(id)
-        { }
+  public:
+    PIDController(const std::string& id, ZoneInterface* owner) :
+        _owner(owner), _setpoint(0), _id(id)
+    {
+    }
 
-        virtual ~PIDController() { }
+    virtual ~PIDController()
+    {
+    }
 
-        virtual float input_proc(void) = 0;
-        virtual float setpt_proc(void) = 0;
-        virtual void output_proc(float value) = 0;
+    virtual float input_proc(void) = 0;
+    virtual float setpt_proc(void) = 0;
+    virtual void output_proc(float value) = 0;
 
-        void pid_process(void);
+    void pid_process(void);
 
-        std::string get_id(void)
-        {
-            return _id;
-        }
-        float get_setpoint(void)
-        {
-            return _setpoint;
-        }
-        void set_setpoint(float setpoint)
-        {
-            _setpoint = setpoint;
-        }
+    std::string get_id(void)
+    {
+        return _id;
+    }
+    float get_setpoint(void)
+    {
+        return _setpoint;
+    }
+    void set_setpoint(float setpoint)
+    {
+        _setpoint = setpoint;
+    }
 
-        ec::pid_info_t* get_pid_info(void)
-        {
-            return &_pid_info;
-        }
+    ec::pid_info_t* get_pid_info(void)
+    {
+        return &_pid_info;
+    }
 
-    protected:
-        ZoneInterface* _owner;
+  protected:
+    ZoneInterface* _owner;
 
-    private:
-        // parameters
-        ec::pid_info_t  _pid_info;
-        float           _setpoint;
-        std::string     _id;
+  private:
+    // parameters
+    ec::pid_info_t _pid_info;
+    float _setpoint;
+    std::string _id;
 };
-
diff --git a/pid/ec/pid.cpp b/pid/ec/pid.cpp
index a1c4e41..ef0df14 100644
--- a/pid/ec/pid.cpp
+++ b/pid/ec/pid.cpp
@@ -53,15 +53,15 @@
     // calculate P, I, D, FF
 
     // Pid
-    error   = setpoint - input;
-    p_term  = pidinfoptr->p_c * error;
+    error = setpoint - input;
+    p_term = pidinfoptr->p_c * error;
 
     // pId
     if (0.0f != pidinfoptr->i_c)
     {
-        i_term  = pidinfoptr->integral;
-        i_term  += error * pidinfoptr->i_c * pidinfoptr->ts;
-        i_term  = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+        i_term = pidinfoptr->integral;
+        i_term += error * pidinfoptr->i_c * pidinfoptr->ts;
+        i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
     }
 
     // FF
@@ -79,8 +79,8 @@
         if (pidinfoptr->slew_neg != 0.0f)
         {
             // Don't decrease too fast
-            float min_out = pidinfoptr->last_output + pidinfoptr->slew_neg *
-                            pidinfoptr->ts;
+            float min_out =
+                pidinfoptr->last_output + pidinfoptr->slew_neg * pidinfoptr->ts;
             if (output < min_out)
             {
                 output = min_out;
@@ -89,8 +89,8 @@
         if (pidinfoptr->slew_pos != 0.0f)
         {
             // Don't increase too fast
-            float max_out = pidinfoptr->last_output + pidinfoptr->slew_pos *
-                            pidinfoptr->ts;
+            float max_out =
+                pidinfoptr->last_output + pidinfoptr->slew_pos * pidinfoptr->ts;
             if (output > max_out)
             {
                 output = max_out;
@@ -107,12 +107,12 @@
 
     // Clamp again because having limited the output may result in a
     // larger integral term
-    i_term  = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+    i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
     pidinfoptr->integral = i_term;
-    pidinfoptr->initialized    = true;
-    pidinfoptr->last_output    = output;
+    pidinfoptr->initialized = true;
+    pidinfoptr->last_output = output;
 
     return output;
 }
 
-}
+} // namespace ec
diff --git a/pid/ec/pid.hpp b/pid/ec/pid.hpp
index e138933..6b1030a 100644
--- a/pid/ec/pid.hpp
+++ b/pid/ec/pid.hpp
@@ -7,8 +7,8 @@
 
 typedef struct
 {
-    float       min;
-    float       max;
+    float min;
+    float max;
 } limits_t;
 
 /* Note: If you update these structs you need to update the copy code in
@@ -16,21 +16,21 @@
  */
 typedef struct
 {
-    bool        initialized;        // has pid been initialized
+    bool initialized; // has pid been initialized
 
-    float       ts;                 // sample time in seconds
-    float       integral;           // intergal of error
-    float       last_output;        // value of last output
+    float ts;          // sample time in seconds
+    float integral;    // intergal of error
+    float last_output; // value of last output
 
-    float       p_c;                // coeff for P
-    float       i_c;                // coeff for I
-    float       ff_off;             // offset coeff for feed-forward term
-    float       ff_gain;            // gain for feed-forward term
+    float p_c;     // coeff for P
+    float i_c;     // coeff for I
+    float ff_off;  // offset coeff for feed-forward term
+    float ff_gain; // gain for feed-forward term
 
-    limits_t    i_lim;              // clamp of integral
-    limits_t    out_lim;            // clamp of output
-    float       slew_neg;
-    float       slew_pos;
+    limits_t i_lim;   // clamp of integral
+    limits_t out_lim; // clamp of output
+    float slew_neg;
+    float slew_pos;
 } pid_info_t;
 
 float pid(pid_info_t* pidinfoptr, float input, float setpoint);
@@ -38,16 +38,15 @@
 /* Condensed version for use by the configuration. */
 struct pidinfo
 {
-    float        ts;                 // sample time in seconds
-    float        p_c;                // coeff for P
-    float        i_c;                // coeff for I
-    float        ff_off;             // offset coeff for feed-forward term
-    float        ff_gain;            // gain for feed-forward term
-    ec::limits_t i_lim;              // clamp of integral
-    ec::limits_t out_lim;            // clamp of output
-    float        slew_neg;
-    float        slew_pos;
+    float ts;             // sample time in seconds
+    float p_c;            // coeff for P
+    float i_c;            // coeff for I
+    float ff_off;         // offset coeff for feed-forward term
+    float ff_gain;        // gain for feed-forward term
+    ec::limits_t i_lim;   // clamp of integral
+    ec::limits_t out_lim; // clamp of output
+    float slew_neg;
+    float slew_pos;
 };
 
-
-}
+} // namespace ec
diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
index 9407689..4a94458 100644
--- a/pid/fancontroller.cpp
+++ b/pid/fancontroller.cpp
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-#include <algorithm>
-#include <iostream>
-
 #include "fancontroller.hpp"
+
 #include "util.hpp"
 #include "zone.hpp"
 
-std::unique_ptr<PIDController> FanController::CreateFanPid(
-    ZoneInterface* owner,
-    const std::string& id,
-    std::vector<std::string>& inputs,
-    ec::pidinfo initial)
+#include <algorithm>
+#include <iostream>
+
+std::unique_ptr<PIDController>
+    FanController::CreateFanPid(ZoneInterface* owner, const std::string& id,
+                                std::vector<std::string>& inputs,
+                                ec::pidinfo initial)
 {
     if (inputs.size() == 0)
     {
@@ -79,7 +79,7 @@
         /* When this is a configuration option in a later update, this code
          * will be updated.
          */
-        //value = sum / _inputs.size();
+        // value = sum / _inputs.size();
 
         /* the fan PID algorithm was unstable with average, and seemed to work
          * better with minimum.  I had considered making this choice a variable
@@ -145,4 +145,3 @@
 
     return;
 }
-
diff --git a/pid/fancontroller.hpp b/pid/fancontroller.hpp
index 3354bb6..aaccd4b 100644
--- a/pid/fancontroller.hpp
+++ b/pid/fancontroller.hpp
@@ -1,14 +1,13 @@
 #pragma once
 
+#include "controller.hpp"
+#include "ec/pid.hpp"
+#include "fan.hpp"
+
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "controller.hpp"
-#include "fan.hpp"
-#include "ec/pid.hpp"
-
-
 /*
  * A FanController is a PID controller that reads a number of fans and given
  * the output then tries to set them to the goal values set by the thermal
@@ -16,36 +15,33 @@
  */
 class FanController : public PIDController
 {
-    public:
-        static std::unique_ptr<PIDController> CreateFanPid(
-            ZoneInterface* owner,
-            const std::string& id,
-            std::vector<std::string>& inputs,
-            ec::pidinfo initial);
+  public:
+    static std::unique_ptr<PIDController>
+        CreateFanPid(ZoneInterface* owner, const std::string& id,
+                     std::vector<std::string>& inputs, ec::pidinfo initial);
 
-        FanController(const std::string& id,
-                      std::vector<std::string>& inputs,
-                      ZoneInterface* owner)
-            : PIDController(id, owner),
-              _inputs(inputs),
-              _direction(FanSpeedDirection::NEUTRAL)
-        { }
+    FanController(const std::string& id, std::vector<std::string>& inputs,
+                  ZoneInterface* owner) :
+        PIDController(id, owner),
+        _inputs(inputs), _direction(FanSpeedDirection::NEUTRAL)
+    {
+    }
 
-        float input_proc(void) override;
-        float setpt_proc(void) override;
-        void output_proc(float value) override;
+    float input_proc(void) override;
+    float setpt_proc(void) override;
+    void output_proc(float value) override;
 
-        FanSpeedDirection getFanDirection(void) const
-        {
-            return _direction;
-        }
+    FanSpeedDirection getFanDirection(void) const
+    {
+        return _direction;
+    }
 
-        void setFanDirection(FanSpeedDirection direction)
-        {
-            _direction = direction;
-        };
+    void setFanDirection(FanSpeedDirection direction)
+    {
+        _direction = direction;
+    };
 
-    private:
-        std::vector<std::string> _inputs;
-        FanSpeedDirection _direction;
+  private:
+    std::vector<std::string> _inputs;
+    FanSpeedDirection _direction;
 };
diff --git a/pid/pidthread.cpp b/pid/pidthread.cpp
index d387ac9..490b70e 100644
--- a/pid/pidthread.cpp
+++ b/pid/pidthread.cpp
@@ -14,17 +14,16 @@
  * limitations under the License.
  */
 
-#include <chrono>
-#include <map>
-#include <memory>
-#include <thread>
-#include <vector>
-
 #include "pidthread.hpp"
 
 #include "pid/controller.hpp"
 #include "sensors/sensor.hpp"
 
+#include <chrono>
+#include <map>
+#include <memory>
+#include <thread>
+#include <vector>
 
 static void ProcessThermals(PIDZone* zone)
 {
@@ -38,7 +37,6 @@
     zone->determineMaxRPMRequest();
 }
 
-
 void PIDControlThread(PIDZone* zone)
 {
     int ms100cnt = 0;
@@ -104,5 +102,3 @@
 
     return;
 }
-
-
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index 81e3e80..1422bef 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -15,16 +15,13 @@
  */
 
 #include "thermalcontroller.hpp"
+
 #include "util.hpp"
 #include "zone.hpp"
 
-
 std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
-    ZoneInterface* owner,
-    const std::string& id,
-    std::vector<std::string>& inputs,
-    float setpoint,
-    ec::pidinfo initial)
+    ZoneInterface* owner, const std::string& id,
+    std::vector<std::string>& inputs, float setpoint, ec::pidinfo initial)
 {
     // ThermalController currently only supports precisely one input.
     if (inputs.size() != 1)
@@ -42,7 +39,7 @@
     return thermal;
 }
 
-//bmc_host_sensor_value_float
+// bmc_host_sensor_value_float
 float ThermalController::input_proc(void)
 {
     /*
@@ -79,4 +76,3 @@
 
     return;
 }
-
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
index 32d4a7f..ed94acb 100644
--- a/pid/thermalcontroller.hpp
+++ b/pid/thermalcontroller.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
-#include <memory>
-#include <string>
-#include <vector>
-
 #include "controller.hpp"
 #include "ec/pid.hpp"
 
+#include <memory>
+#include <string>
+#include <vector>
 
 /*
  * A ThermalController is a PID controller that reads a number of sensors and
@@ -14,26 +13,23 @@
  */
 class ThermalController : public PIDController
 {
-    public:
-        static std::unique_ptr<PIDController> CreateThermalPid(
-            ZoneInterface* owner,
-            const std::string& id,
-            std::vector<std::string>& inputs,
-            float setpoint,
-            ec::pidinfo initial);
+  public:
+    static std::unique_ptr<PIDController>
+        CreateThermalPid(ZoneInterface* owner, const std::string& id,
+                         std::vector<std::string>& inputs, float setpoint,
+                         ec::pidinfo initial);
 
-        ThermalController(const std::string& id,
-                          std::vector<std::string>& inputs,
-                          ZoneInterface* owner)
-            : PIDController(id, owner),
-              _inputs(inputs)
-        { }
+    ThermalController(const std::string& id, std::vector<std::string>& inputs,
+                      ZoneInterface* owner) :
+        PIDController(id, owner),
+        _inputs(inputs)
+    {
+    }
 
-        float input_proc(void) override;
-        float setpt_proc(void) override;
-        void output_proc(float value) override;
+    float input_proc(void) override;
+    float setpt_proc(void) override;
+    void output_proc(float value) override;
 
-    private:
-        std::vector<std::string> _inputs;
+  private:
+    std::vector<std::string> _inputs;
 };
-
diff --git a/pid/util.cpp b/pid/util.cpp
index 79da7e1..9004059 100644
--- a/pid/util.cpp
+++ b/pid/util.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
+#include "ec/pid.hpp"
+
 #include <cstring>
 #include <iostream>
 
-#include "ec/pid.hpp"
-
 void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial)
 {
     std::memset(info, 0x00, sizeof(ec::pid_info_t));
@@ -36,12 +36,10 @@
     info->slew_pos = initial->slew_pos;
 }
 
-void DumpPIDStruct(ec::pid_info_t *info)
+void DumpPIDStruct(ec::pid_info_t* info)
 {
-    std::cerr << " ts: " << info->ts
-              << " p_c: " << info->p_c
-              << " i_c: " << info->i_c
-              << " ff_off: " << info->ff_off
+    std::cerr << " ts: " << info->ts << " p_c: " << info->p_c
+              << " i_c: " << info->i_c << " ff_off: " << info->ff_off
               << " ff_gain: " << info->ff_gain
               << " i_lim.min: " << info->i_lim.min
               << " i_lim.max: " << info->i_lim.max
@@ -50,8 +48,7 @@
               << " slew_neg: " << info->slew_neg
               << " slew_pos: " << info->slew_pos
               << " last_output: " << info->last_output
-              << " integral: " << info->integral
-              << std::endl;
+              << " integral: " << info->integral << std::endl;
 
     return;
 }
diff --git a/pid/util.hpp b/pid/util.hpp
index eb6e713..0f37afe 100644
--- a/pid/util.hpp
+++ b/pid/util.hpp
@@ -2,11 +2,10 @@
 
 #include "ec/pid.hpp"
 
-
 /*
  * Given a configuration structure, fill out the information we use within the
  * PID loop.
  */
 void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial);
 
-void DumpPIDStruct(ec::pid_info_t *info);
+void DumpPIDStruct(ec::pid_info_t* info);
diff --git a/pid/zone.cpp b/pid/zone.cpp
index fdf16fc..9e948f0 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -15,10 +15,14 @@
  */
 
 /* Configuration. */
-#include "conf.hpp"
-
 #include "zone.hpp"
 
+#include "conf.hpp"
+#include "pid/controller.hpp"
+#include "pid/ec/pid.hpp"
+#include "pid/fancontroller.hpp"
+#include "pid/thermalcontroller.hpp"
+
 #include <algorithm>
 #include <chrono>
 #include <cstring>
@@ -27,12 +31,6 @@
 #include <libconfig.h++>
 #include <memory>
 
-#include "pid/controller.hpp"
-#include "pid/fancontroller.hpp"
-#include "pid/thermalcontroller.hpp"
-#include "pid/ec/pid.hpp"
-
-
 using tstamp = std::chrono::high_resolution_clock::time_point;
 using namespace std::literals::chrono_literals;
 
@@ -136,7 +134,8 @@
         int value;
         std::ifstream ifs;
         ifs.open(setpointpath);
-        if (ifs.good()) {
+        if (ifs.good())
+        {
             ifs >> value;
             max = value; // expecting RPM set-point, not pwm%
         }
@@ -202,7 +201,9 @@
      */
 #ifdef __TUNING_LOGGING__
     tstamp now = std::chrono::high_resolution_clock::now();
-    _log << std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+    _log << std::chrono::duration_cast<std::chrono::milliseconds>(
+                now.time_since_epoch())
+                .count();
     _log << "," << _maximumRPMSetPt;
 #endif
 
@@ -252,12 +253,12 @@
          */
         if (timeout > 0)
         {
-            auto duration = duration_cast<std::chrono::seconds>
-                    (now - then).count();
+            auto duration =
+                duration_cast<std::chrono::seconds>(now - then).count();
             auto period = std::chrono::seconds(timeout).count();
             if (duration >= period)
             {
-                //std::cerr << "Entering fail safe mode.\n";
+                // std::cerr << "Entering fail safe mode.\n";
                 _failSafeSensors.insert(t);
             }
             else
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 1934a66..99a8f14 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -1,39 +1,36 @@
 #pragma once
 
+#include "conf.hpp"
+#include "controller.hpp"
+#include "sensors/manager.hpp"
+#include "sensors/sensor.hpp"
+#include "xyz/openbmc_project/Control/Mode/server.hpp"
+
 #include <fstream>
 #include <map>
 #include <memory>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server.hpp>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "conf.hpp"
-#include "controller.hpp"
-#include "sensors/sensor.hpp"
-#include "sensors/manager.hpp"
-
-#include "xyz/openbmc_project/Control/Mode/server.hpp"
-#include <sdbusplus/bus.hpp>
-#include <sdbusplus/server.hpp>
-
-
 template <typename... T>
 using ServerObject = typename sdbusplus::server::object::object<T...>;
-using ModeInterface =
-    sdbusplus::xyz::openbmc_project::Control::server::Mode;
+using ModeInterface = sdbusplus::xyz::openbmc_project::Control::server::Mode;
 using ModeObject = ServerObject<ModeInterface>;
 
 class ZoneInterface
 {
-    public:
-        virtual ~ZoneInterface() = default;
+  public:
+    virtual ~ZoneInterface() = default;
 
-        virtual double getCachedValue(const std::string& name) = 0;
-        virtual void addRPMSetPoint(float setpoint) = 0;
-        virtual float getMaxRPMRequest() const = 0;
-        virtual bool getFailSafeMode() const = 0;
-        virtual float getFailSafePercent() const = 0;
-        virtual Sensor* getSensor(std::string name) = 0;
+    virtual double getCachedValue(const std::string& name) = 0;
+    virtual void addRPMSetPoint(float setpoint) = 0;
+    virtual float getMaxRPMRequest() const = 0;
+    virtual bool getFailSafeMode() const = 0;
+    virtual float getFailSafePercent() const = 0;
+    virtual Sensor* getSensor(std::string name) = 0;
 };
 
 /*
@@ -43,84 +40,77 @@
  */
 class PIDZone : public ZoneInterface, public ModeObject
 {
-    public:
-        PIDZone(int64_t zone,
-                float minThermalRpm,
-                float failSafePercent,
-                const SensorManager& mgr,
-                sdbusplus::bus::bus& bus,
-                const char* objPath,
-                bool defer)
-            : ModeObject(bus, objPath, defer),
-              _zoneId(zone),
-              _maximumRPMSetPt(),
-              _minThermalRpmSetPt(minThermalRpm),
-              _failSafePercent(failSafePercent),
-              _mgr(mgr)
-        {
+  public:
+    PIDZone(int64_t zone, float minThermalRpm, float failSafePercent,
+            const SensorManager& mgr, sdbusplus::bus::bus& bus,
+            const char* objPath, bool defer) :
+        ModeObject(bus, objPath, defer),
+        _zoneId(zone), _maximumRPMSetPt(), _minThermalRpmSetPt(minThermalRpm),
+        _failSafePercent(failSafePercent), _mgr(mgr)
+    {
 #ifdef __TUNING_LOGGING__
-            _log.open("/tmp/swampd.log");
+        _log.open("/tmp/swampd.log");
 #endif
-        }
+    }
 
-        float getMaxRPMRequest(void) const override;
-        bool getManualMode(void) const;
+    float getMaxRPMRequest(void) const override;
+    bool getManualMode(void) const;
 
-        /* Could put lock around this since it's accessed from two threads, but
-         * only one reader/one writer.
-         */
-        void setManualMode(bool mode);
-        bool getFailSafeMode(void) const override;
-        int64_t getZoneId(void) const;
-        void addRPMSetPoint(float setpoint) override;
-        void clearRPMSetPoints(void);
-        float getFailSafePercent(void) const override;
-        float getMinThermalRpmSetPt(void) const;
+    /* Could put lock around this since it's accessed from two threads, but
+     * only one reader/one writer.
+     */
+    void setManualMode(bool mode);
+    bool getFailSafeMode(void) const override;
+    int64_t getZoneId(void) const;
+    void addRPMSetPoint(float setpoint) override;
+    void clearRPMSetPoints(void);
+    float getFailSafePercent(void) const override;
+    float getMinThermalRpmSetPt(void) const;
 
-        Sensor* getSensor(std::string name) override;
-        void determineMaxRPMRequest(void);
-        void updateFanTelemetry(void);
-        void updateSensors(void);
-        void initializeCache(void);
-        void dumpCache(void);
-        void process_fans(void);
-        void process_thermals(void);
+    Sensor* getSensor(std::string name) override;
+    void determineMaxRPMRequest(void);
+    void updateFanTelemetry(void);
+    void updateSensors(void);
+    void initializeCache(void);
+    void dumpCache(void);
+    void process_fans(void);
+    void process_thermals(void);
 
-        void addFanPID(std::unique_ptr<PIDController> pid);
-        void addThermalPID(std::unique_ptr<PIDController> pid);
-        double getCachedValue(const std::string& name) override;
-        void addFanInput(std::string fan);
-        void addThermalInput(std::string therm);
+    void addFanPID(std::unique_ptr<PIDController> pid);
+    void addThermalPID(std::unique_ptr<PIDController> pid);
+    double getCachedValue(const std::string& name) override;
+    void addFanInput(std::string fan);
+    void addThermalInput(std::string therm);
 
 #ifdef __TUNING_LOGGING__
-        void initializeLog(void);
-        std::ofstream& getLogHandle(void);
+    void initializeLog(void);
+    std::ofstream& getLogHandle(void);
 #endif
 
-        /* Method for setting the manual mode over dbus */
-        bool manual(bool value) override;
-        /* Method for reading whether in fail-safe mode over dbus */
-        bool failSafe() const override;
+    /* Method for setting the manual mode over dbus */
+    bool manual(bool value) override;
+    /* Method for reading whether in fail-safe mode over dbus */
+    bool failSafe() const override;
 
-    private:
+  private:
 #ifdef __TUNING_LOGGING__
-        std::ofstream _log;
+    std::ofstream _log;
 #endif
 
-        const int64_t _zoneId;
-        float _maximumRPMSetPt = 0;
-        bool _manualMode = false;
-        const float _minThermalRpmSetPt;
-        const float _failSafePercent;
+    const int64_t _zoneId;
+    float _maximumRPMSetPt = 0;
+    bool _manualMode = false;
+    const float _minThermalRpmSetPt;
+    const float _failSafePercent;
 
-        std::set<std::string> _failSafeSensors;
+    std::set<std::string> _failSafeSensors;
 
-        std::vector<float> _RPMSetPoints;
-        std::vector<std::string> _fanInputs;
-        std::vector<std::string> _thermalInputs;
-        std::map<std::string, double> _cachedValuesByName;
-        const SensorManager& _mgr;
+    std::vector<float> _RPMSetPoints;
+    std::vector<std::string> _fanInputs;
+    std::vector<std::string> _thermalInputs;
+    std::map<std::string, double> _cachedValuesByName;
+    const SensorManager& _mgr;
 
-        std::vector<std::unique_ptr<PIDController>> _fans;
-        std::vector<std::unique_ptr<PIDController>> _thermals;
+    std::vector<std::unique_ptr<PIDController>> _fans;
+    std::vector<std::unique_ptr<PIDController>> _thermals;
 };