Merge pull request #288 from alekgajos/smearing_optimization

Add a built-in implementation of default MC smearing functions
JPETTomography · Apr 4, 2023 · 522a7ef · 522a7ef
2 parents 5f71424 + bc68a81
commit 522a7ef
Showing 4 changed files with 161 additions and 3 deletions.
diff --git a/include/GeantParser/JPetGeantParser/JPetGeantParser.h b/include/GeantParser/JPetGeantParser/JPetGeantParser.h
@@ -65,6 +65,16 @@ class JPetGeantParser : public JPetUserTask
   double fExperimentalThreshold = 10; //< in keV
   unsigned long fSeed = 0.;
 
+  bool fUseDefaultZSmearing = false;
+  bool fUseDefaultTimeSmearing = false;
+  bool fUseDefaultEnergySmearing = false;
+
+  float fDefaultZSmearingSigma = 3.0;
+  float fDefaultTimeSmearingSigma = 220.0;
+  float fDefaultTimeSmearingThresholdEnergy = 200.0;
+  float fDefaultTimeSmearingReferenceEnergy = 270.0;
+  float fDefaultEnergySmearingFraction = 0.044;
+
   JPetHitExperimentalParametrizer fExperimentalParametrizer;
 
   // internal variables
@@ -88,6 +98,17 @@ class JPetGeantParser : public JPetUserTask
   const std::string kZPositionSmearingFunctionParamKey = "GeantParser_ZPositionSmearingFunction_std::string";
   const std::string kZPositionSmearingFunctionLimitsParamKey = "GeantParser_ZPositionSmearingFunctionLimits_std::vector<double>";
 
+  const std::string kUseDefaultZSmearingKey = "GeantParser_UseDefaultZSmearing_bool";
+  const std::string kDefaultZSmearingSigmaKey = "GeantParser_DefaultZSmearingSigma_double";
+
+  const std::string kUseDefaultTimeSmearingKey = "GeantParser_UseDefaultTimeSmearing_bool";
+  const std::string kDefaultTimeSmearingSigmaKey = "GeantParser_DefaultTimeSmearingSigma_double";
+  const std::string kDefaultTimeSmearingThresholdEnergyKey = "GeantParser_DefaultTimeSmearingThresholdEnergy_double";
+  const std::string kDefaultTimeSmearingReferenceEnergyKey = "GeantParser_DefaultTimeSmearingReferenceEnergy_double";
+
+  const std::string kUseDefaultEnergySmearingKey = "GeantParser_UseDefaultEnergySmearing_bool";
+  const std::string kDefaultEnergySmearingFractionKey = "GeantParser_DefaultEnergySmearingFraction_double";
+
   const std::string kSeedParamKey = "GeantParser_Seed_int";
 
   long fExpectedNumberOfEvents = 0;

diff --git a/include/GeantParser/JPetSmearingFunctions/JPetSmearingFunctions.h b/include/GeantParser/JPetSmearingFunctions/JPetSmearingFunctions.h
@@ -79,9 +79,49 @@ class JPetHitExperimentalParametrizer
 
   void setSmearingFunctionLimits(const std::vector<std::pair<double, double>>& limits);
 
+  void setShouldUseDefaultSmearing(bool defaultZ, bool defaultTime, bool defaultEnergy){
+    fUseDefaultZSmearing = defaultZ;
+    fUseDefaultTimeSmearing = defaultTime;
+    fUseDefaultEnergySmearing = defaultEnergy;
+  }
+
+  void setDefaultZSmearingSigma(double sigma){
+    fDefaultZSmearingSigma = sigma;
+  } 
+
+  void setDefaultTimeSmearingSigma(double sigma){
+    fDefaultTimeSmearingSigma = sigma;
+  }
+
+  void setDefaultTimeSmearingThresholdEnergy(double thresholdEnergy){
+    fDefaultTimeSmearingThresholdEnergy = thresholdEnergy;
+  }
+
+  void setDefaultTimeSmearingReferenceEnergy(double referenceEnergy){
+    fDefaultTimeSmearingReferenceEnergy = referenceEnergy;
+  }
+
+  void setDefaultEnergySmearingFraction(double fraction){
+    fDefaultEnergySmearingFraction = fraction;
+  }
+
 private:
+  double defaultTimeSmearing(double zIn, double eneIn, double timeIn);
+  double defaultEnergySmearing(double zIn, double eneIn, double timeIn);
+  double defaultZHitSmearing(double zIn, double eneIn, double timeIn);
+
   std::map<SmearingType, FuncPtr> fSmearingFunctions;
   std::map<SmearingType, SmearingFunctionLimits> fFunctionLimits{{kTime, {-300, 300}}, {kEnergy, {-100, 100}}, {kZPosition, {-5, 5}}};
+
+  bool fUseDefaultZSmearing = false;
+  bool fUseDefaultTimeSmearing = false;
+  bool fUseDefaultEnergySmearing = false;
+
+  double fDefaultZSmearingSigma = 3.0; // cm
+  double fDefaultTimeSmearingSigma = 220.0; // ps
+  double fDefaultTimeSmearingThresholdEnergy = 200.0; // keV
+  double fDefaultTimeSmearingReferenceEnergy = 270.0; // keV
+  double fDefaultEnergySmearingFraction = 0.044;
 };
 
 #endif
diff --git a/src/GeantParser/JPetGeantParser/JPetGeantParser.cpp b/src/GeantParser/JPetGeantParser/JPetGeantParser.cpp
@@ -144,11 +144,52 @@ void JPetGeantParser::loadSmearingOptionsAndSetupExperimentalParametrizer()
   }
 
   std::vector<double> zPositionSmearingLimits;
+
   if (isOptionSet(fParams.getOptions(), kZPositionSmearingFunctionLimitsParamKey))
   {
     zPositionSmearingLimits = getOptionAsVectorOfDoubles(fParams.getOptions(), kZPositionSmearingFunctionLimitsParamKey);
   }
 
+  if (isOptionSet(fParams.getOptions(), kUseDefaultZSmearingKey))
+  {
+    fUseDefaultZSmearing = getOptionAsDouble(fParams.getOptions(), kUseDefaultZSmearingKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kUseDefaultTimeSmearingKey))
+  {
+    fUseDefaultTimeSmearing = getOptionAsDouble(fParams.getOptions(), kUseDefaultTimeSmearingKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kUseDefaultEnergySmearingKey))
+  {
+    fUseDefaultEnergySmearing = getOptionAsDouble(fParams.getOptions(), kUseDefaultEnergySmearingKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kDefaultZSmearingSigmaKey))
+  {
+   fDefaultZSmearingSigma = getOptionAsDouble(fParams.getOptions(), kDefaultZSmearingSigmaKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kDefaultTimeSmearingSigmaKey))
+  {
+   fDefaultTimeSmearingSigma = getOptionAsDouble(fParams.getOptions(), kDefaultTimeSmearingSigmaKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kDefaultTimeSmearingThresholdEnergyKey))
+  {
+   fDefaultTimeSmearingThresholdEnergy = getOptionAsDouble(fParams.getOptions(), kDefaultTimeSmearingThresholdEnergyKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kDefaultTimeSmearingReferenceEnergyKey))
+  {
+   fDefaultTimeSmearingReferenceEnergy = getOptionAsDouble(fParams.getOptions(), kDefaultTimeSmearingReferenceEnergyKey);
+  }
+
+  if (isOptionSet(fParams.getOptions(), kDefaultEnergySmearingFractionKey))
+  {
+   fDefaultEnergySmearingFraction = getOptionAsDouble(fParams.getOptions(), kDefaultEnergySmearingFractionKey);
+  }
+
   fExperimentalParametrizer.setSmearingFunctions({{timeSmearingFormula, timeSmearingParameters},
                                                   {energySmearingFormula, energySmearingParameters},
                                                   {zPositionSmearingFormula, zPositionSmearingParameters}});
@@ -183,6 +224,22 @@ void JPetGeantParser::loadSmearingOptionsAndSetupExperimentalParametrizer()
   }
 
   fExperimentalParametrizer.setSmearingFunctionLimits(limits);
+
+  fExperimentalParametrizer.setShouldUseDefaultSmearing(fUseDefaultZSmearing, fUseDefaultTimeSmearing, fUseDefaultEnergySmearing);
+
+  if(fUseDefaultZSmearing){
+    fExperimentalParametrizer.setDefaultZSmearingSigma(fDefaultZSmearingSigma);
+  }
+
+  if(fUseDefaultTimeSmearing){
+    fExperimentalParametrizer.setDefaultTimeSmearingSigma(fDefaultTimeSmearingSigma);
+    fExperimentalParametrizer.setDefaultTimeSmearingReferenceEnergy(fDefaultTimeSmearingReferenceEnergy);
+    fExperimentalParametrizer.setDefaultTimeSmearingThresholdEnergy(fDefaultTimeSmearingThresholdEnergy);
+  }
+
+  if(fUseDefaultEnergySmearing){
+    fExperimentalParametrizer.setDefaultEnergySmearingFraction(fDefaultEnergySmearingFraction);
+  }
 }
 
 bool JPetGeantParser::exec()

diff --git a/src/GeantParser/JPetSmearingFunctions/JPetSmearingFunctions.cpp b/src/GeantParser/JPetSmearingFunctions/JPetSmearingFunctions.cpp
@@ -17,14 +17,17 @@
 #include <JPetSmearingFunctions/JPetSmearingFunctions.h>
 
 #include <TMath.h>
+#include <TRandom.h>
+#include <iostream>
 
 using SmearingType = JPetHitExperimentalParametrizer::SmearingType;
 using SmearingFunctionLimits = JPetHitExperimentalParametrizer::SmearingFunctionLimits;
 
 JPetHitExperimentalParametrizer::JPetHitExperimentalParametrizer()
 {
 
-  auto timeSmearingF = [&](double* x, double* p) -> double {
+  auto timeSmearingF = [&](double* x, double* p) -> double
+  {
     // p[0] = scinID
     // p[1] = zIn
     // p[2] = eneIn
@@ -57,7 +60,8 @@ JPetHitExperimentalParametrizer::JPetHitExperimentalParametrizer()
   fSmearingFunctions[kTime]->SetParameter(5, kEnergyThreshold);
   fSmearingFunctions[kTime]->SetParameter(6, kReferenceEnergy);
 
-  auto energySmearingF = [&](double* x, double* p) -> double {
+  auto energySmearingF = [&](double* x, double* p) -> double
+  {
     // p[0] = scinID
     // p[1] = zIn
     // p[2] = eneIn
@@ -71,7 +75,8 @@ JPetHitExperimentalParametrizer::JPetHitExperimentalParametrizer()
 
   fSmearingFunctions.emplace(kEnergy, std::make_unique<TF1>("funEnergySmearing", energySmearingF, -200., 200., 4));
 
-  auto zPositionSmearingF = [&](double* x, double* p) -> double {
+  auto zPositionSmearingF = [&](double* x, double* p) -> double
+  {
     // p[0] = scinID
     // p[1] = zIn
     // p[2] = eneIn
@@ -217,6 +222,9 @@ std::map<SmearingType, SmearingFunctionLimits> JPetHitExperimentalParametrizer::
 /// function is randomize in the range [lowLim + timeIn, highLim + timeIn]
 double JPetHitExperimentalParametrizer::addTimeSmearing(int scinID, double zIn, double eneIn, double timeIn)
 {
+  if(fUseDefaultTimeSmearing) {
+    return defaultTimeSmearing(zIn, eneIn, timeIn);
+  }
   /// We cannot use setParameters(...) cause if there are more then 4 parameters
   /// It would set it all to 0.
   fSmearingFunctions[kTime]->SetParameter(0, double(scinID));
@@ -230,6 +238,10 @@ double JPetHitExperimentalParametrizer::addTimeSmearing(int scinID, double zIn,
 /// function is randomize in the range [lowLim + eneIn, highLim + eneIn]
 double JPetHitExperimentalParametrizer::addEnergySmearing(int scinID, double zIn, double eneIn, double timeIn)
 {
+  if(fUseDefaultEnergySmearing) {
+    return defaultEnergySmearing(zIn, eneIn, timeIn);
+  }
+
   fSmearingFunctions[kEnergy]->SetParameter(0, double(scinID));
   fSmearingFunctions[kEnergy]->SetParameter(1, zIn);
   fSmearingFunctions[kEnergy]->SetParameter(2, eneIn);
@@ -241,6 +253,10 @@ double JPetHitExperimentalParametrizer::addEnergySmearing(int scinID, double zIn
 /// function is randomize in the range [lowLim + zIn, highLim + zIn]
 double JPetHitExperimentalParametrizer::addZHitSmearing(int scinID, double zIn, double eneIn, double timeIn)
 {
+  if(fUseDefaultZSmearing) {
+    return defaultZHitSmearing(zIn, eneIn, timeIn);
+  }
+
   /// We cannot use setParameters(...) cause if there are more then 4 parameters
   /// It would set it all to 0.
   fSmearingFunctions[kZPosition]->SetParameter(0, double(scinID));
@@ -250,3 +266,27 @@ double JPetHitExperimentalParametrizer::addZHitSmearing(int scinID, double zIn,
   fSmearingFunctions[kZPosition]->SetRange(zIn + fFunctionLimits[kZPosition].first, zIn + fFunctionLimits[kZPosition].second);
   return fSmearingFunctions[kZPosition]->GetRandom();
 }
+
+double JPetHitExperimentalParametrizer::defaultTimeSmearing(double /* zIn */, double eneIn, double timeIn)
+{
+  double random_norm_gaus = gRandom->Gaus(0.0, 1.0);
+  double sigma = fDefaultTimeSmearingSigma;
+  if (eneIn < fDefaultTimeSmearingThresholdEnergy){
+    sigma /= sqrt(eneIn / fDefaultTimeSmearingReferenceEnergy);
+  }
+  return timeIn + random_norm_gaus * sigma;
+}
+
+double JPetHitExperimentalParametrizer::defaultEnergySmearing(double /* zIn */, double eneIn, double /* timeIn */)
+{
+  double random_norm_gaus = gRandom->Gaus(0.0, 1.0);
+  double sigma = fDefaultEnergySmearingFraction * eneIn / sqrt(eneIn / 1000.);
+  return eneIn + random_norm_gaus * sigma;
+}
+
+double JPetHitExperimentalParametrizer::defaultZHitSmearing(double zIn, double /* eneIn */, double /* timeIn */)
+{
+  double random_norm_gaus = gRandom->Gaus(0.0, 1.0);
+  double sigma = fDefaultZSmearingSigma;
+  return zIn + random_norm_gaus * sigma;
+}