Merge pull request #227 from bigladder/make-generic-update

Make generic update

Author: nealkruis

src/CMakeLists.txt

@@ -14,6 +14,7 @@ set_target_properties(${PROJECT_NAME}_version_header PROPERTIES FOLDER Dependenc
 set(headers
         HPWHversion.in.hh
         HPWH.hh
+        HPWHFitter.hh
         )
 
 set(sources
@@ -22,6 +23,7 @@ set(sources
         HPWHHeatSources.cc
         HPWHHeatingLogics.cc
         HPWHpresets.cc
+        HPWHFitter.cc
         )
 
 set(library_sources

src/HPWH.cc

@@ -619,11 +619,11 @@ class HPWH : public Courier::Sender
     };
     void setMinutesPerStep(double newMinutesPerStep);
 
-    int WriteCSVHeading(std::ofstream& outFILE,
+    int writeCSVHeading(std::ofstream& outFILE,
                         const char* preamble = "",
                         int nTCouples = 6,
                         int options = CSVOPT_NONE) const;
-    int WriteCSVRow(std::ofstream& outFILE,
+    int writeCSVRow(std::ofstream& outFILE,
                     const char* preamble = "",
                     int nTCouples = 6,
                     int options = CSVOPT_NONE) const;
@@ -999,26 +999,41 @@ class HPWH : public Courier::Sender
     /// first-hour rating designations to determine draw pattern for 24-hr test
     struct FirstHourRating
     {
-        enum class Desig
+        enum class Designation
         {
             VerySmall,
             Low,
             Medium,
             High
-        };
+        } designation;
 
-        static inline std::unordered_map<Desig, std::string> sDesigMap = {
-            {Desig::VerySmall, "Very Small"},
-            {Desig::Low, "Low"},
-            {Desig::Medium, "Medium"},
-            {Desig::High, "High"}};
+        static inline std::unordered_map<Designation, std::string> DesignationMap = {
+            {Designation::VerySmall, "Very Small"},
+            {Designation::Low, "Low"},
+            {Designation::Medium, "Medium"},
+            {Designation::High, "High"}};
 
-        Desig desig;
         double drawVolume_L;
+        std::string report();
     };
 
-    /// collection of information derived from standard test
-    struct StandardTestSummary
+    /// fields for test output to csv
+    struct TestData
+    {
+        int time_min;
+        double ambientT_C;
+        double setpointT_C;
+        double inletT_C;
+        double drawVolume_L;
+        DRMODES drMode;
+        std::vector<double> h_srcIn_kWh;
+        std::vector<double> h_srcOut_kWh;
+        std::vector<double> thermocoupleT_C;
+        double outletT_C;
+    };
+
+    /// collection of information derived from standard 24-h test
+    struct TestSummary
     {
         // first recovery values
         double recoveryEfficiency = 0.; // eta_r
@@ -1045,8 +1060,8 @@ class HPWH : public Courier::Sender
         // 24-hr values
         double removedVolume_L = 0.;
         double waterHeatingEnergy_kJ = 0.; // Q_HW
-        double avgOutletT_C = 0.;          // <Tdel,i>
-        double avgInletT_C = 0.;           // <Tin,i>
+        double averageOutletT_C = 0.;      // <Tdel,i>
+        double averageInletT_C = 0.;       // <Tin,i>
 
         double usedFossilFuelEnergy_kJ = 0.;               // Q_f
         double usedElectricalEnergy_kJ = 0.;               // Q_e
@@ -1055,97 +1070,104 @@ class HPWH : public Courier::Sender
         double standardWaterHeatingEnergy_kJ = 0.;         // Q_HW,T
         double adjustedConsumedWaterHeatingEnergy_kJ = 0.; // Q_da
         double modifiedConsumedWaterHeatingEnergy_kJ = 0.; // Q_dm
-        double UEF = 0.;
+        double EF = 0.;
 
         // (calculated) annual totals
         double annualConsumedElectricalEnergy_kJ = 0.; // E_annual,e
         double annualConsumedEnergy_kJ = 0.;           // E_annual
 
         bool qualifies = false;
+
+        std::vector<TestData> testDataSet = {};
+
+        // return a verbose string summary
+        std::string report();
     };
 
-    struct StandardTestOptions
+    struct TestConfiguration
     {
-        bool saveOutput = false;
-        std::string sOutputDirectory = "";
-        std::string sOutputFilename = "";
-        std::ostream* outputStream = &std::cout;
-        bool changeSetpoint = false;
-        std::ofstream outputFile;
-        int nTestTCouples = 6;
-        double setpointT_C = 51.7;
+        double ambientT_C;
+        double inletT_C;
+        double externalT_C;
     };
 
+    static TestConfiguration testConfiguration_E50;
+    static TestConfiguration testConfiguration_UEF;
+    static TestConfiguration testConfiguration_E95;
+    static double testSetpointT_C;
+
     /// perform a draw/heat cycle to prepare for test
-    void prepForTest(StandardTestOptions& standardTestOptions);
+    void prepareForTest(const TestConfiguration& test_configuration);
 
     /// determine first-hour rating
-    void findFirstHourRating(FirstHourRating& firstHourRating,
-                             StandardTestOptions& standardTestOptions);
+    FirstHourRating findFirstHourRating();
 
-    /// run 24-hr draw pattern and compute metrics
-    void run24hrTest(const FirstHourRating firstHourRating,
-                     StandardTestSummary& standardTestSummary,
-                     StandardTestOptions& standardTestOptions);
+    /// run 24-hr draw pattern
+    TestSummary run24hrTest(TestConfiguration testConfiguration,
+                            FirstHourRating::Designation designation,
+                            bool saveOutput = false);
+    TestSummary run24hrTest(TestConfiguration testConfiguration, bool saveOutput = false)
+    {
+        return run24hrTest(testConfiguration, findFirstHourRating().designation, saveOutput);
+    }
 
     /// specific information for a single draw
     struct Draw
     {
         double startTime_min;
         double volume_L;
-        double flowRate_Lper_min;
+        double flowRate_L_per_min;
 
         Draw(const double startTime_min_in,
              const double volume_L_in,
              const double flowRate_Lper_min_in)
             : startTime_min(startTime_min_in)
             , volume_L(volume_L_in)
-            , flowRate_Lper_min(flowRate_Lper_min_in)
+            , flowRate_L_per_min(flowRate_Lper_min_in)
         {
         }
     };
 
     /// sequence of draws in pattern
     typedef std::vector<Draw> DrawPattern;
 
-    static std::unordered_map<FirstHourRating::Desig, std::size_t> firstDrawClusterSizes;
+    static std::unordered_map<FirstHourRating::Designation, std::size_t> firstDrawClusterSizes;
 
     /// collection of standard draw patterns
-    static std::unordered_map<FirstHourRating::Desig, DrawPattern> drawPatterns;
+    static std::unordered_map<FirstHourRating::Designation, DrawPattern> drawPatterns;
 
-    /// fields for test output to csv
-    struct OutputData
-    {
-        int time_min;
-        double ambientT_C;
-        double setpointT_C;
-        double inletT_C;
-        double drawVolume_L;
-        DRMODES drMode;
-        std::vector<double> h_srcIn_kWh;
-        std::vector<double> h_srcOut_kWh;
-        std::vector<double> thermocoupleT_C;
-        double outletT_C;
-    };
+    struct Fitter;
 
-    int writeRowAsCSV(std::ofstream& outFILE,
-                      OutputData& outputData,
-                      const CSVOPTIONS& options = CSVOPTIONS::CSVOPT_NONE) const;
+    /// fit using a single configuration
+    TestSummary makeGenericEF(double targetEF,
+                              TestConfiguration testConfiguration,
+                              FirstHourRating::Designation designation);
+    TestSummary makeGenericEF(double targetEF, TestConfiguration testConfiguration)
+    {
+        return makeGenericEF(targetEF, testConfiguration, findFirstHourRating().designation);
+    }
 
-    void measureMetrics(FirstHourRating& firstHourRating,
-                        StandardTestOptions& standardTestOptions,
-                        StandardTestSummary& standardTestSummary);
+    /// fit using each of three configurations, independently
+    void makeGenericE50_UEF_E95(double targetE50,
+                                double targetUEF,
+                                double targetE95,
+                                FirstHourRating::Designation designation);
 
-    struct CustomTestOptions
+    void makeGenericE50_UEF_E95(double targetE50, double targetUEF, double targetE95)
     {
-        bool overrideFirstHourRating = false;
-        FirstHourRating::Desig desig = FirstHourRating::Desig::VerySmall;
-    } customTestOptions;
+        return makeGenericE50_UEF_E95(
+            targetE50, targetUEF, targetE95, findFirstHourRating().designation);
+    }
 
-    void makeGeneric(const double targetUEF);
+    /// fit using UEF config, then adjust E50, E95 coefficients
+    TestSummary makeGenericUEF(double targetUEF, FirstHourRating::Designation designation);
+    TestSummary makeGenericUEF(double targetUEF)
+    {
+        return makeGenericUEF(targetUEF, findFirstHourRating().designation);
+    }
 
   private:
-    void setAllDefaults(); /**< sets all the defaults default */
+    void setAllDefaults(); /**< sets all the defaults */
 
     void updateTankTemps(
         double draw, double inletT_C, double ambientT_C, double inletVol2_L, double inletT2_L);
@@ -1444,16 +1466,18 @@ class HPWH::HeatSource : public Courier::Sender
     void defrostDerate(double& to_derate, double airT_C);
     /**< Derates the COP of a system based on the air temperature */
 
-    struct perfPoint
+    struct PerformancePoint
     {
         double T_F;
         std::vector<double> inputPower_coeffs; // c0 + c1*T + c2*T*T
         std::vector<double> COP_coeffs;        // c0 + c1*T + c2*T*T
     };
 
-    std::vector<perfPoint> perfMap;
+    std::vector<PerformancePoint> performanceMap;
     /**< A map with input/COP quadratic curve coefficients at a given external temperature */
 
+    int getAmbientT_index(double ambientT_C);
+
   private:
     // start with a few type definitions
     enum COIL_CONFIG