FlatEvtVtxGenerator: do check on R/Phi limits only if UseCylindricalCoords is chosen and other fixes

IOMC/EventVertexGenerators/interface/FlatEvtVtxGenerator.h

@@ -13,6 +13,7 @@
  *
  */
 
+#include <optional>
 #include "IOMC/EventVertexGenerators/interface/BaseEvtVtxGenerator.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 
@@ -27,7 +28,7 @@ class FlatEvtVtxGenerator : public BaseEvtVtxGenerator {
   FlatEvtVtxGenerator(const FlatEvtVtxGenerator& p) = delete;
   /** Copy assignment operator */
   FlatEvtVtxGenerator& operator=(const FlatEvtVtxGenerator& rhs) = delete;
-  ~FlatEvtVtxGenerator() override;
+  ~FlatEvtVtxGenerator() override = default;
 
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
@@ -42,18 +43,33 @@ class FlatEvtVtxGenerator : public BaseEvtVtxGenerator {
   inline void minY(double m = 0.0) { fMinY = m; }
   /// set min in Z in cm
   inline void minZ(double m = 0.0) { fMinZ = m; }
+  /// set min in R in cm
+  inline void minR(double m = 0.0) { fMinR = m; }
+  /// set min in phi in rad
+  inline void minPhi(double m = 0.0) { fMinPhi = m; }
 
   /// set max in X in cm
   inline void maxX(double m = 0) { fMaxX = m; }
   /// set max in Y in cm
   inline void maxY(double m = 0) { fMaxY = m; }
   /// set max in Z in cm
   inline void maxZ(double m = 0) { fMaxZ = m; }
+  /// set max in R in cm
+  inline void maxR(double m = 0.0) { fMaxR = m; }
+  /// set max in phi in rad
+  inline void maxPhi(double m = 0.0) { fMaxPhi = m; }
 
 private:
-  double fMinX, fMinY, fMinZ, fMinT, fMinR, fMinPhi;
-  double fMaxX, fMaxY, fMaxZ, fMaxT, fMaxR, fMaxPhi;
-  bool fFixedR;
+  // parameters always configured
+  const bool fUseCylindricalCoords;
+  double fMinZ, fMaxZ;
+  double fMinT, fMaxT;
+
+  // parameters conditionally configured
+  std::optional<double> fMaxX, fMaxY;
+  std::optional<double> fMinX, fMinY;
+  std::optional<double> fMinR, fMaxR;
+  std::optional<double> fMinPhi, fMaxPhi;
 };
 
 #endif

IOMC/EventVertexGenerators/python/VtxDisplacedFlat_cfi.py

@@ -5,6 +5,3 @@
     FlatVtxDisplacedParameters,
     src = cms.InputTag("generator", "unsmeared"),
 )
-
-
-

IOMC/EventVertexGenerators/python/VtxSmearedParameters_cfi.py

@@ -85,7 +85,7 @@
 # Can restore correlation via MinT += (MinZ - MaxZ)/2 and MaxT += (MaxZ - MinZ)/2
 # in [ns] units (recall c_light = 29.98cm/ns)
 FlatVtxSmearingParameters = cms.PSet(
-    FixedR = cms.bool(False),
+    UseCylindricalCoords = cms.bool(False),
     MaxZ = cms.double(5.3),
     MaxX = cms.double(0.0015),
     MaxY = cms.double(0.0015),
@@ -97,7 +97,7 @@
 )
 
 FlatVtxDisplacedParameters = cms.PSet(
-    FixedR = cms.bool(True),
+    UseCylindricalCoords = cms.bool(True),
     MaxR = cms.double(10.1),
     MinR = cms.double(10.0),
     MaxZ = cms.double(0.001),

IOMC/EventVertexGenerators/src/FlatEvtVtxGenerator.cc

@@ -1,43 +1,46 @@
-#include "IOMC/EventVertexGenerators/interface/FlatEvtVtxGenerator.h"
-#include "FWCore/Utilities/interface/Exception.h"
+// system includes
+#include <numbers>
+#include <CLHEP/Random/RandFlat.h>
+#include <CLHEP/Units/GlobalPhysicalConstants.h>
+#include <CLHEP/Units/SystemOfUnits.h>
 
+// user includes
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
-
-#include <CLHEP/Random/RandFlat.h>
-#include <CLHEP/Units/SystemOfUnits.h>
-#include <CLHEP/Units/GlobalPhysicalConstants.h>
+#include "FWCore/Utilities/interface/Exception.h"
+#include "IOMC/EventVertexGenerators/interface/FlatEvtVtxGenerator.h"
 
 using CLHEP::cm;
 using CLHEP::ns;
 using CLHEP::radian;
 
-FlatEvtVtxGenerator::FlatEvtVtxGenerator(const edm::ParameterSet& p) : BaseEvtVtxGenerator(p) {
-  fFixedR = p.getParameter<bool>("FixedR");
-  if (fFixedR) {
+FlatEvtVtxGenerator::FlatEvtVtxGenerator(const edm::ParameterSet& p)
+    : BaseEvtVtxGenerator(p),
+      fUseCylindricalCoords(p.getParameter<bool>("UseCylindricalCoords")),
+      fMinZ(p.getParameter<double>("MinZ") * cm),
+      fMaxZ(p.getParameter<double>("MaxZ") * cm),
+      fMinT(p.getParameter<double>("MinT") * ns * c_light),
+      fMaxT(p.getParameter<double>("MaxT") * ns * c_light) {
+  if (fUseCylindricalCoords) {
     fMaxR = p.getParameter<double>("MaxR") * cm;
     fMinR = p.getParameter<double>("MinR") * cm;
     fMaxPhi = p.getParameter<double>("MaxPhi") * radian;
     fMinPhi = p.getParameter<double>("MinPhi") * radian;
+    fMinX = std::nullopt;
+    fMaxX = std::nullopt;
+    fMinY = std::nullopt;
+    fMaxY = std::nullopt;
   } else {
     fMinX = p.getParameter<double>("MinX") * cm;
     fMaxX = p.getParameter<double>("MaxX") * cm;
     fMinY = p.getParameter<double>("MinY") * cm;
     fMaxY = p.getParameter<double>("MaxY") * cm;
+    fMaxR = std::nullopt;
+    fMinR = std::nullopt;
+    fMaxPhi = std::nullopt;
+    fMinPhi = std::nullopt;
   }
-  fMaxZ = p.getParameter<double>("MaxZ") * cm;
-  fMinZ = p.getParameter<double>("MinZ") * cm;
-  fMinT = p.getParameter<double>("MinT") * ns * c_light;
-  fMaxT = p.getParameter<double>("MaxT") * ns * c_light;
 
-  if (fMinX > fMaxX) {
-    throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
-                                          << "MinX is greater than MaxX";
-  }
-  if (fMinY > fMaxY) {
-    throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
-                                          << "MinY is greater than MaxY";
-  }
   if (fMinZ > fMaxZ) {
     throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
                                           << "MinZ is greater than MaxZ";
@@ -46,31 +49,47 @@ FlatEvtVtxGenerator::FlatEvtVtxGenerator(const edm::ParameterSet& p) : BaseEvtVt
     throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
                                           << "MinT is greater than MaxT";
   }
-  if (fMinR > fMaxR) {
-    throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
-                                          << "MinR is greater than MaxR";
-  }
-  if (fMinPhi > fMaxPhi) {
-    throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
-                                          << "MinPhi is greater than MaxPhi";
+
+  // configuration dependent checks
+  if (fUseCylindricalCoords) {
+    if (fMinR.value() > fMaxR.value()) {
+      throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
+                                            << "MinR is greater than MaxR";
+    }
+    if (fMinPhi.value() > fMaxPhi.value()) {
+      throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
+                                            << "MinPhi is greater than MaxPhi";
+    }
+
+    edm::LogVerbatim("FlatEvtVtx") << "FlatEvtVtxGenerator Initialized with r[" << *fMinR << ":" << *fMaxR
+                                   << "] cm; phi[" << *fMinPhi << ":" << *fMaxPhi << "] rad; z[" << fMinZ << ":"
+                                   << fMaxZ << "] cm; t[" << fMinT << ":" << fMaxT << "] mm";
+  } else {
+    if (fMinX.value() > fMaxX.value()) {
+      throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
+                                            << "MinX is greater than MaxX";
+    }
+    if (fMinY.value() > fMaxY.value()) {
+      throw cms::Exception("Configuration") << "Error in FlatEvtVtxGenerator: "
+                                            << "MinY is greater than MaxY";
+    }
+
+    edm::LogVerbatim("FlatEvtVtx") << "FlatEvtVtxGenerator Initialized with x[" << *fMinX << ":" << *fMaxX << "] cm; y["
+                                   << *fMinY << ":" << *fMaxY << "] cm; z[" << fMinZ << ":" << fMaxZ << "] cm; t["
+                                   << fMinT << ":" << fMaxT << "] mm" << std::endl;
   }
-  edm::LogVerbatim("FlatEvtVtx") << "FlatEvtVtxGenerator Initialized with x[" << fMinX << ":" << fMaxX << "] cm; y["
-                                 << fMinY << ":" << fMaxY << "] cm; z[" << fMinZ << ":" << fMaxZ << "] cm; t[" << fMinT
-                                 << ":" << fMaxT << "]";
 }
 
-FlatEvtVtxGenerator::~FlatEvtVtxGenerator() {}
-
 ROOT::Math::XYZTVector FlatEvtVtxGenerator::vertexShift(CLHEP::HepRandomEngine* engine) const {
   double aX, aY, aZ, aT;
-  if (fFixedR) {
-    double aR = CLHEP::RandFlat::shoot(engine, fMinR, fMaxR);
-    double aPhi = CLHEP::RandFlat::shoot(engine, fMinPhi, fMaxPhi);
+  if (fUseCylindricalCoords) {
+    double aR = CLHEP::RandFlat::shoot(engine, *fMinR, *fMaxR);
+    double aPhi = CLHEP::RandFlat::shoot(engine, *fMinPhi, *fMaxPhi);
     aX = aR * std::cos(aPhi);
     aY = aR * std::sin(aPhi);
   } else {
-    aX = CLHEP::RandFlat::shoot(engine, fMinX, fMaxX);
-    aY = CLHEP::RandFlat::shoot(engine, fMinY, fMaxY);
+    aX = CLHEP::RandFlat::shoot(engine, *fMinX, *fMaxX);
+    aY = CLHEP::RandFlat::shoot(engine, *fMinY, *fMaxY);
   }
   aZ = CLHEP::RandFlat::shoot(engine, fMinZ, fMaxZ);
   aT = CLHEP::RandFlat::shoot(engine, fMinT, fMaxT);
@@ -83,19 +102,23 @@ ROOT::Math::XYZTVector FlatEvtVtxGenerator::vertexShift(CLHEP::HepRandomEngine*
 
 void FlatEvtVtxGenerator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
   edm::ParameterSetDescription desc;
-  desc.add<double>("MinX", 0.0)->setComment("in cm");
-  desc.add<double>("MaxX", 0.001)->setComment("in cm");
-  desc.add<double>("MinY", 0.0)->setComment("in cm");
-  desc.add<double>("MaxY", 0.001)->setComment("in cm");
   desc.add<double>("MinZ", 0.0)->setComment("in cm");
   desc.add<double>("MaxZ", 0.001)->setComment("in cm");
   desc.add<double>("MinT", 0.0)->setComment("in ns");
   desc.add<double>("MaxT", 0.001)->setComment("in ns");
-  desc.add<bool>("FixedR", false);
-  desc.add<double>("MinR", 0.0)->setComment("in cm");
-  desc.add<double>("MaxR", 0.001)->setComment("in cm");
-  desc.add<double>("MinPhi", -3.14159265359)->setComment("in radians");
-  desc.add<double>("MaxPhi", 3.14159265359)->setComment("in radians");
   desc.add<edm::InputTag>("src");
-  descriptions.add("FlatEvtVtxGenerator", desc);
+
+  desc.ifValue(edm::ParameterDescription<bool>("UseCylindricalCoords", false, true),
+               // Cartesian (UseCylindricalCoords = false) branch
+               (false >> (edm::ParameterDescription<double>("MinX", 0.0, true) and
+                          edm::ParameterDescription<double>("MaxX", 0.001, true) and
+                          edm::ParameterDescription<double>("MinY", 0.0, true) and
+                          edm::ParameterDescription<double>("MaxY", 0.001, true))) or
+                   // Cylindrical (UseCylindricalCoords = true) branch
+                   (true >> (edm::ParameterDescription<double>("MinR", 0.0, true) and
+                             edm::ParameterDescription<double>("MaxR", 0.001, true) and
+                             edm::ParameterDescription<double>("MinPhi", -std::numbers::pi, true) and
+                             edm::ParameterDescription<double>("MaxPhi", std::numbers::pi, true))));
+
+  descriptions.addWithDefaultLabel(desc);
 }