Merge pull request #48291 from Dr15Jones/consistenBeamSpotOnlineProducer

cmsbuild · web-flow · commit 4b2c72105eca · 2025-06-12T23:47:13.000+02:00
Make BeamSpotOnlineProducer return consistent results
diff --git a/RecoVertex/BeamSpotProducer/plugins/BeamSpotOnlineProducer.cc b/RecoVertex/BeamSpotProducer/plugins/BeamSpotOnlineProducer.cc
@@ -31,6 +31,8 @@ ________________________________________________________________**/
 #include "FWCore/Utilities/interface/ESGetToken.h"
 #include "FWCore/Utilities/interface/TypeDemangler.h"
 
+#include <optional>
+
 class BeamSpotOnlineProducer : public edm::stream::EDProducer<> {
 public:
   /// constructor
@@ -47,17 +49,19 @@ class BeamSpotOnlineProducer : public edm::stream::EDProducer<> {
 private:
   // helper methods
   bool shouldShout(const edm::Event& iEvent) const;
-  bool processRecords(const edm::LuminosityBlock& iLumi, const edm::EventSetup& iSetup, bool shoutMODE);
-  void createBeamSpotFromRecord(const BeamSpotObjects& spotDB);
+  std::optional<reco::BeamSpot> processRecords(const edm::LuminosityBlock& iLumi,
+                                               const edm::EventSetup& iSetup,
+                                               bool shoutMODE) const;
+  reco::BeamSpot createBeamSpotFromRecord(const BeamSpotObjects& spotDB) const;
   template <typename RecordType, typename TokenType>
-  const BeamSpotOnlineObjects& getBeamSpotFromRecord(const TokenType& token,
+  const BeamSpotOnlineObjects* getBeamSpotFromRecord(const TokenType& token,
                                                      const edm::LuminosityBlock& lumi,
-                                                     const edm::EventSetup& setup);
-  const BeamSpotOnlineObjects& chooseBS(const BeamSpotOnlineObjects& bs1, const BeamSpotOnlineObjects& bs2);
-  bool processScalers(const edm::Event& iEvent, bool shoutMODE);
-  void createBeamSpotFromScaler(const BeamSpotOnline& spotOnline);
+                                                     const edm::EventSetup& setup) const;
+  const BeamSpotOnlineObjects* chooseBS(const BeamSpotOnlineObjects* bs1, const BeamSpotOnlineObjects* bs2) const;
+  std::optional<reco::BeamSpot> processScalers(const edm::Event& iEvent, bool shoutMODE) const;
+  reco::BeamSpot createBeamSpotFromScaler(const BeamSpotOnline& spotOnline) const;
   bool isInvalidScaler(const BeamSpotOnline& spotOnline, bool shoutMODE) const;
-  void createBeamSpotFromDB(const edm::EventSetup& iSetup, bool shoutMODE);
+  reco::BeamSpot createBeamSpotFromDB(const edm::EventSetup& iSetup, bool shoutMODE) const;
 
   // data members
   const bool changeFrame_;
@@ -72,9 +76,8 @@ class BeamSpotOnlineProducer : public edm::stream::EDProducer<> {
   const edm::ESGetToken<BeamSpotOnlineObjects, BeamSpotOnlineLegacyObjectsRcd> beamTokenLegacy_;
   const edm::ESGetToken<BeamSpotOnlineObjects, BeamSpotOnlineHLTObjectsRcd> beamTokenHLT_;
 
-  reco::BeamSpot result;
+  std::optional<reco::BeamSpot> lumiResult_;
   const unsigned int theBeamShoutMode;
-  BeamSpotOnlineObjects fakeBS_;
 };
 
 using namespace edm;
@@ -90,13 +93,12 @@ BeamSpotOnlineProducer::BeamSpotOnlineProducer(const ParameterSet& iconf)
       scalerToken_(useBSOnlineRecords_ ? edm::EDGetTokenT<BeamSpotOnlineCollection>()
                                        : consumes<BeamSpotOnlineCollection>(iconf.getParameter<InputTag>("src"))),
       l1GtEvmReadoutRecordToken_(consumes<L1GlobalTriggerEvmReadoutRecord>(iconf.getParameter<InputTag>("gtEvmLabel"))),
-      beamToken_(esConsumes<BeamSpotObjects, BeamSpotObjectsRcd>()),
+      beamToken_(esConsumes<BeamSpotObjects, BeamSpotObjectsRcd, edm::Transition::BeginLuminosityBlock>()),
       beamTokenLegacy_(
           esConsumes<BeamSpotOnlineObjects, BeamSpotOnlineLegacyObjectsRcd, edm::Transition::BeginLuminosityBlock>()),
       beamTokenHLT_(
           esConsumes<BeamSpotOnlineObjects, BeamSpotOnlineHLTObjectsRcd, edm::Transition::BeginLuminosityBlock>()),
       theBeamShoutMode(iconf.getUntrackedParameter<unsigned int>("beamMode", 11)) {
-  fakeBS_.setType(reco::BeamSpot::Fake);
   theMaxR2 = iconf.getParameter<double>("maxRadius");
   theMaxR2 *= theMaxR2;
 
@@ -122,29 +124,29 @@ void BeamSpotOnlineProducer::fillDescriptions(edm::ConfigurationDescriptions& iD
 void BeamSpotOnlineProducer::beginLuminosityBlock(const edm::LuminosityBlock& lumi, const edm::EventSetup& setup) {
   /// fetch online records only at the beginning of a lumisection
   if (useBSOnlineRecords_) {
-    processRecords(lumi, setup, true);
+    lumiResult_ = processRecords(lumi, setup, true);
+    if (lumiResult_)
+      return;
   }
+  lumiResult_ = createBeamSpotFromDB(setup, true);
 }
 
 void BeamSpotOnlineProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   // Determine if we should "shout" based on the beam mode
   bool shoutMODE = shouldShout(iEvent);
-  bool fallBackToDB{false};
 
-  // Use online records if enabled
-  if (useBSOnlineRecords_) {
-    fallBackToDB = result.type() != reco::BeamSpot::Tracker;
-  } else {
+  std::unique_ptr<reco::BeamSpot> toput;
+  if (not useBSOnlineRecords_) {
     // Process online beam spot scalers
-    fallBackToDB = processScalers(iEvent, shoutMODE);
+    auto bs = processScalers(iEvent, shoutMODE);
+    if (bs) {
+      toput = std::make_unique<reco::BeamSpot>(std::move(*bs));
+    }
   }
-
-  // Fallback to DB if necessary
-  if (fallBackToDB) {
-    createBeamSpotFromDB(iSetup, shoutMODE);
+  if (not toput) {
+    assert(lumiResult_);
+    toput = std::make_unique<reco::BeamSpot>(*lumiResult_);
   }
-
-  std::unique_ptr<reco::BeamSpot> toput = std::make_unique<reco::BeamSpot>(result);
   iEvent.put(std::move(toput));
 }
 
@@ -156,80 +158,82 @@ bool BeamSpotOnlineProducer::shouldShout(const edm::Event& iEvent) const {
   return true;  // Default to "shout" if the record is missing
 }
 
-bool BeamSpotOnlineProducer::processRecords(const edm::LuminosityBlock& iLumi,
-                                            const edm::EventSetup& iSetup,
-                                            bool shoutMODE) {
-  auto const& spotDBLegacy = getBeamSpotFromRecord<BeamSpotOnlineLegacyObjectsRcd>(beamTokenLegacy_, iLumi, iSetup);
-  auto const& spotDBHLT = getBeamSpotFromRecord<BeamSpotOnlineHLTObjectsRcd>(beamTokenHLT_, iLumi, iSetup);
-  auto const& spotDB = chooseBS(spotDBLegacy, spotDBHLT);
+std::optional<reco::BeamSpot> BeamSpotOnlineProducer::processRecords(const edm::LuminosityBlock& iLumi,
+                                                                     const edm::EventSetup& iSetup,
+                                                                     bool shoutMODE) const {
+  auto const* spotDBLegacy = getBeamSpotFromRecord<BeamSpotOnlineLegacyObjectsRcd>(beamTokenLegacy_, iLumi, iSetup);
+  auto const* spotDBHLT = getBeamSpotFromRecord<BeamSpotOnlineHLTObjectsRcd>(beamTokenHLT_, iLumi, iSetup);
+  auto const* spotDB = chooseBS(spotDBLegacy, spotDBHLT);
 
-  if (spotDB.beamType() != reco::BeamSpot::Tracker) {
+  if (not spotDB) {
     if (shoutMODE) {
       edm::LogWarning("BeamSpotOnlineProducer") << "None of the online records holds a valid beam spot. The Online "
                                                    "Beam Spot producer falls back to the PCL value.";
     }
-    return true;  // Trigger fallback to DB
+    return {};  // Trigger fallback to DB
   }
 
   // Create BeamSpot from transient record
-  createBeamSpotFromRecord(spotDB);
-  return false;  // No fallback needed
+  return createBeamSpotFromRecord(*spotDB);
 }
 
 template <typename RecordType, typename TokenType>
-const BeamSpotOnlineObjects& BeamSpotOnlineProducer::getBeamSpotFromRecord(const TokenType& token,
+const BeamSpotOnlineObjects* BeamSpotOnlineProducer::getBeamSpotFromRecord(const TokenType& token,
                                                                            const LuminosityBlock& lumi,
-                                                                           const EventSetup& setup) {
+                                                                           const EventSetup& setup) const {
   auto const bsRecord = setup.tryToGet<RecordType>();
-  const auto& recordTypeName = edm::typeDemangle(typeid(RecordType).name());
   if (!bsRecord) {
+    const auto& recordTypeName = edm::typeDemangle(typeid(RecordType).name());
     edm::LogWarning("BeamSpotOnlineProducer") << "No " << recordTypeName << " found in the EventSetup";
-    return fakeBS_;
+    return nullptr;
   }
   const auto& bsHandle = setup.getHandle(token);
   if (bsHandle.isValid()) {
     const auto& bs = *bsHandle;
     if (bs.sigmaZ() < sigmaZThreshold_ || bs.beamWidthX() < sigmaXYThreshold_ || bs.beamWidthY() < sigmaXYThreshold_ ||
         bs.beamType() != reco::BeamSpot::Tracker) {
+      const auto& recordTypeName = edm::typeDemangle(typeid(RecordType).name());
       edm::LogWarning("BeamSpotOnlineProducer")
           << "The beam spot record does not pass the fit sanity checks (record: " << recordTypeName << ")" << std::endl
           << "sigmaZ: " << bs.sigmaZ() << std::endl
           << "sigmaX: " << bs.beamWidthX() << std::endl
           << "sigmaY: " << bs.beamWidthY() << std::endl
           << "type: " << bs.beamType();
-      return fakeBS_;
+      return nullptr;
     }
     auto lumitime = std::chrono::seconds(lumi.beginTime().unixTime());
     auto bstime = std::chrono::microseconds(bs.creationTime());
     auto threshold = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::hours(timeThreshold_)).count();
     if ((lumitime - bstime).count() > threshold) {
+      const auto& recordTypeName = edm::typeDemangle(typeid(RecordType).name());
       edm::LogWarning("BeamSpotOnlineProducer")
           << "The beam spot record is too old. (record: " << recordTypeName << ")" << std::endl
           << " record creation time: " << std::chrono::duration_cast<std::chrono::seconds>(bstime).count()
           << " lumi block time: " << std::chrono::duration_cast<std::chrono::seconds>(lumitime).count();
-      return fakeBS_;
+      return nullptr;
     }
-    return bs;
+    return &bs;
   } else {
+    const auto& recordTypeName = edm::typeDemangle(typeid(RecordType).name());
     edm::LogWarning("BeamSpotOnlineProducer") << "Invalid online beam spot handle for the record: " << recordTypeName;
-    return fakeBS_;
+    return nullptr;
   }
 }
 
-const BeamSpotOnlineObjects& BeamSpotOnlineProducer::chooseBS(const BeamSpotOnlineObjects& bs1,
-                                                              const BeamSpotOnlineObjects& bs2) {
-  if (bs1.beamType() == reco::BeamSpot::Tracker && bs2.beamType() == reco::BeamSpot::Tracker) {
-    return bs1.sigmaZ() > bs2.sigmaZ() ? bs1 : bs2;
-  } else if (bs1.beamType() == reco::BeamSpot::Tracker) {
+const BeamSpotOnlineObjects* BeamSpotOnlineProducer::chooseBS(const BeamSpotOnlineObjects* bs1,
+                                                              const BeamSpotOnlineObjects* bs2) const {
+  if (bs1 and bs2 and bs1->beamType() == reco::BeamSpot::Tracker && bs2->beamType() == reco::BeamSpot::Tracker) {
+    return bs1->sigmaZ() > bs2->sigmaZ() ? bs1 : bs2;
+  } else if (bs1 and bs1->beamType() == reco::BeamSpot::Tracker) {
     return bs1;
-  } else if (bs2.beamType() == reco::BeamSpot::Tracker) {
+  } else if (bs2 and bs2->beamType() == reco::BeamSpot::Tracker) {
     return bs2;
   } else {
-    return fakeBS_;
+    return nullptr;
   }
 }
 
-void BeamSpotOnlineProducer::createBeamSpotFromRecord(const BeamSpotObjects& spotDB) {
+reco::BeamSpot BeamSpotOnlineProducer::createBeamSpotFromRecord(const BeamSpotObjects& spotDB) const {
   double f = changeFrame_ ? -1.0 : 1.0;
   reco::BeamSpot::Point apoint(f * spotDB.x(), f * spotDB.y(), f * spotDB.z());
 
@@ -241,15 +245,16 @@ void BeamSpotOnlineProducer::createBeamSpotFromRecord(const BeamSpotObjects& spo
   }
 
   double sigmaZ = (theSetSigmaZ > 0) ? theSetSigmaZ : spotDB.sigmaZ();
-  result = reco::BeamSpot(apoint, sigmaZ, spotDB.dxdz(), spotDB.dydz(), spotDB.beamWidthX(), matrix);
+  reco::BeamSpot result(apoint, sigmaZ, spotDB.dxdz(), spotDB.dydz(), spotDB.beamWidthX(), matrix);
   result.setBeamWidthY(spotDB.beamWidthY());
   result.setEmittanceX(spotDB.emittanceX());
   result.setEmittanceY(spotDB.emittanceY());
   result.setbetaStar(spotDB.betaStar());
   result.setType(reco::BeamSpot::Tracker);
+  return result;
 }
 
-bool BeamSpotOnlineProducer::processScalers(const edm::Event& iEvent, bool shoutMODE) {
+std::optional<reco::BeamSpot> BeamSpotOnlineProducer::processScalers(const edm::Event& iEvent, bool shoutMODE) const {
   edm::Handle<BeamSpotOnlineCollection> handleScaler;
   iEvent.getByToken(scalerToken_, handleScaler);
 
@@ -258,21 +263,19 @@ bool BeamSpotOnlineProducer::processScalers(const edm::Event& iEvent, bool shout
       edm::LogWarning("BeamSpotOnlineProducer") << " Scalers handle is empty. The Online "
                                                    "Beam Spot producer falls back to the PCL value.";
     }
-    return true;  // Fallback to DB if scaler collection is empty
+    return {};
   }
 
   // Extract data from scaler
   BeamSpotOnline spotOnline = *(handleScaler->begin());
-  createBeamSpotFromScaler(spotOnline);
-
   // Validate the scaler data
   if (isInvalidScaler(spotOnline, shoutMODE)) {
-    return true;  // Trigger fallback to DB
+    return {};  // Trigger fallback to DB
   }
-  return false;  // No fallback needed
+  return createBeamSpotFromScaler(spotOnline);
 }
 
-void BeamSpotOnlineProducer::createBeamSpotFromScaler(const BeamSpotOnline& spotOnline) {
+reco::BeamSpot BeamSpotOnlineProducer::createBeamSpotFromScaler(const BeamSpotOnline& spotOnline) const {
   double f = changeFrame_ ? -1.0 : 1.0;
   reco::BeamSpot::Point apoint(f * spotOnline.x(), spotOnline.y(), f * spotOnline.z());
 
@@ -283,12 +286,13 @@ void BeamSpotOnlineProducer::createBeamSpotFromScaler(const BeamSpotOnline& spot
   matrix(3, 3) = spotOnline.err_sigma_z() * spotOnline.err_sigma_z();
 
   double sigmaZ = (theSetSigmaZ > 0) ? theSetSigmaZ : spotOnline.sigma_z();
-  result = reco::BeamSpot(apoint, sigmaZ, spotOnline.dxdz(), f * spotOnline.dydz(), spotOnline.width_x(), matrix);
+  reco::BeamSpot result(apoint, sigmaZ, spotOnline.dxdz(), f * spotOnline.dydz(), spotOnline.width_x(), matrix);
   result.setBeamWidthY(spotOnline.width_y());
   result.setEmittanceX(0.0);
   result.setEmittanceY(0.0);
   result.setbetaStar(0.0);
   result.setType(reco::BeamSpot::LHC);
+  return result;
 }
 
 bool BeamSpotOnlineProducer::isInvalidScaler(const BeamSpotOnline& spotOnline, bool shoutMODE) const {
@@ -313,7 +317,7 @@ bool BeamSpotOnlineProducer::isInvalidScaler(const BeamSpotOnline& spotOnline, b
   return false;
 }
 
-void BeamSpotOnlineProducer::createBeamSpotFromDB(const edm::EventSetup& iSetup, bool shoutMODE) {
+reco::BeamSpot BeamSpotOnlineProducer::createBeamSpotFromDB(const edm::EventSetup& iSetup, bool shoutMODE) const {
   edm::ESHandle<BeamSpotObjects> beamhandle = iSetup.getHandle(beamToken_);
   const BeamSpotObjects* spotDB = beamhandle.product();
 
@@ -326,7 +330,7 @@ void BeamSpotOnlineProducer::createBeamSpotFromDB(const edm::EventSetup& iSetup,
     }
   }
 
-  result = reco::BeamSpot(apoint, spotDB->sigmaZ(), spotDB->dxdz(), spotDB->dydz(), spotDB->beamWidthX(), matrix);
+  reco::BeamSpot result(apoint, spotDB->sigmaZ(), spotDB->dxdz(), spotDB->dydz(), spotDB->beamWidthX(), matrix);
   result.setBeamWidthY(spotDB->beamWidthY());
   result.setEmittanceX(spotDB->emittanceX());
   result.setEmittanceY(spotDB->emittanceY());
@@ -337,6 +341,7 @@ void BeamSpotOnlineProducer::createBeamSpotFromDB(const edm::EventSetup& iSetup,
   if ((bse.cxx() <= 0.0) || (bse.cyy() <= 0.0) || (bse.czz() <= 0.0)) {
     edm::LogError("UnusableBeamSpot") << "Beamspot from DB fallback has invalid errors: " << result.covariance();
   }
+  return result;
 }
 
 #include "FWCore/Framework/interface/MakerMacros.h"
