feat: more control of averaging potentials

src/modules/epsrManager/epsrManager.cpp

@@ -20,4 +20,10 @@ EPSRManagerModule::EPSRManagerModule() : Module(ModuleTypes::EPSRManager)
     keywords_.setOrganisation("Options", "Potential Scaling");
     keywords_.add<StringKeyword>("PotScale", "Comma-separated list of atom type pairs and scaling factors in the form A-B=1.0",
                                  potentialScalings_);
+    keywords_.setOrganisation("Options", "Averaging");
+    keywords_.add<OptionalIntegerKeyword>("Averaging", "Number of historical potential sets to combine into final potentials",
+                                          averagingLength_, 1, std::nullopt, 1, "Off");
+    keywords_.add<EnumOptionsKeyword<Averaging::AveragingScheme>>("AveragingScheme",
+                                                                  "Weighting scheme to use when averaging potentials",
+                                                                  averagingScheme_, Averaging::averagingSchemes());
 }

src/modules/epsrManager/epsrManager.h

@@ -5,6 +5,7 @@
 
 #include "classes/scatteringMatrix.h"
 #include "generator/generator.h"
+#include "math/averaging.h"
 #include "module/groups.h"
 #include "module/module.h"
 #include <tuple>
@@ -35,6 +36,12 @@ class EPSRManagerModule : public Module
     };
     // Potential scalings
     std::string potentialScalings_;
+    // Number of historical partial sets to combine into final partials
+    std::optional<int> averagingLength_;
+    // Weighting scheme to use when averaging partials
+    Averaging::AveragingScheme averagingScheme_{Averaging::LinearAveraging};
+    // Vector of averaged potentials over multiple iterations
+    std::vector<std::map<std::string, EPData>> averagedPotentialsStore;
 
     /*
      * Functions

src/modules/epsrManager/process.cpp

@@ -53,6 +53,26 @@ Module::ExecutionResult EPSRManagerModule::process(ModuleContext &moduleContext)
     for (auto &&[key, epData] : potentials)
         epData.ep /= epData.count;
 
+    std::map<std::string, EPData> averagedPotentials = potentials;
+
+    averagedPotentialsStore.emplace_back(potentials);
+    // Check if ran the right amount of iterations before averaging
+    if (averagedPotentialsStore.size() > averagingLength_)
+    {
+        averagedPotentialsStore.pop_back();
+    }
+
+    // Average the potentials and replace the map with the new averaged
+    for (const auto &pots : averagedPotentialsStore)
+    {
+        for (auto &&[key, epData] : pots)
+        {
+            averagedPotentials[key].ep += epData.ep;
+            averagedPotentials[key].ep /= averagingLength_.value();
+        }
+    }
+    potentials = averagedPotentials;
+
     // Apply potential scalings
     auto scalings = DissolveSys::splitString(potentialScalings_, ",");
     for (const auto &scaling : scalings)