[EVO] Fixed merged conflict 2026/04/03

Configuration/Applications/python/ConfigBuilder.py

@@ -1844,6 +1844,47 @@ def prepare_RECOBEFMIX(self, stepSpec = "reconstruction"):
 
     def prepare_PAT(self, stepSpec = "patTask"):
         ''' Enrich the schedule with PAT '''
+
+        # Handle @-prefixed flavors (e.g., @Scout for scouting MiniAOD)
+        if '@' in stepSpec:
+            from PhysicsTools.PatFromScouting.autoPAT import autoPAT, expandPATMapping
+
+            _patSeq = stepSpec.split('+')
+            _patCustoms = stepSpec.split('+')
+            expandPATMapping(_patSeq, autoPAT, 'sequence')
+            expandPATMapping(_patCustoms, autoPAT, 'customize')
+
+            # Remove duplicates while preserving order
+            _patSeq = list(sorted(set(_patSeq), key=_patSeq.index))
+            _patCustoms = list(sorted(set(_patCustoms), key=_patCustoms.index))
+            # Remove empty strings
+            _patSeq = [s for s in _patSeq if s]
+            _patCustoms = [c for c in _patCustoms if c]
+
+            # Load and schedule sequences
+            _seqToSchedule = []
+            for _subSeq in _patSeq:
+                if '.' in _subSeq:
+                    _cff, _seq = _subSeq.rsplit('.', 1)
+                    print(f"PAT: scheduling: {_seq} from {_cff}")
+                    self.loadAndRemember(_cff)
+                    _seqToSchedule.append(_seq)
+                elif '/' in _subSeq:
+                    self.loadAndRemember(_subSeq)
+
+            if _seqToSchedule:
+                self.scheduleSequence('+'.join(_seqToSchedule), 'patMiniAOD_step')
+
+            # Add customizations
+            for custom in _patCustoms:
+                self._options.customisation_file.append(custom)
+
+            # cpu efficiency boost when running PAT by itself
+            if self.stepKeys[0] == 'PAT':
+                self._customise_coms.append( 'process.source.delayReadingEventProducts = cms.untracked.bool(False)')
+
+            return
+
         _,pat_sequence,pat_cff = self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF)
         ## handle the noise filters as Flag_* path that were loaded
         for existing_path,path_ in self.process.paths_().items():
@@ -1888,6 +1929,12 @@ def prepare_NANO(self, stepSpec = '' ):
         print(_nanoSeq)
         # create full specified sequence using autoNANO
         from PhysicsTools.NanoAOD.autoNANO import autoNANO, expandNanoMapping
+        # Extend with scouting-specific NANO flavors if available
+        try:
+            from PhysicsTools.PatFromScouting.autoPAT import autoNANO_scouting
+            autoNANO.update(autoNANO_scouting)
+        except ImportError:
+            pass  # PatFromScouting not available
         # if not a autoNANO mapping, load an empty customization, which later will be converted into the default.
         _nanoCustoms = _nanoSeq.split('+') if '@' in stepSpec else ['']
         _nanoSeq = _nanoSeq.split('+')

DataFormats/MuonReco/interface/Muon.h

@@ -295,6 +295,7 @@ namespace reco {
       static const unsigned int RPCMuon = 1 << 6;
       static const unsigned int GEMMuon = 1 << 7;
       static const unsigned int ME0Muon = 1 << 8;
+      static const unsigned int ScoutingMuon = 1 << 9;
 
       void setType(unsigned int type) { type_ = type; }
       unsigned int type() const { return type_; }
@@ -309,6 +310,7 @@ namespace reco {
       bool isRPCMuon() const { return type_ & RPCMuon; }
       bool isGEMMuon() const { return type_ & GEMMuon; }
       bool isME0Muon() const { return type_ & ME0Muon; }
+      bool isScoutingMuon() const { return type_ & ScoutingMuon; }
 
     private:
       /// check overlap with another candidate

DataFormats/PatCandidates/BuildFile.xml

@@ -23,6 +23,7 @@
 <use name="DataFormats/ParticleFlowCandidate"/>
 <use name="DataFormats/Provenance"/>
 <use name="DataFormats/RecoCandidate"/>
+<use name="DataFormats/Scouting"/>
 <use name="DataFormats/SiPixelDetId"/>
 <use name="DataFormats/SiStripDetId"/>
 <use name="DataFormats/TauReco"/>

DataFormats/PatCandidates/interface/Electron.h

@@ -32,6 +32,9 @@
 #include "DataFormats/PatCandidates/interface/ElectronFwd.h"
 #include "DataFormats/Common/interface/AtomicPtrCache.h"
 
+// Forward declaration for scouting
+class Run3ScoutingElectron;
+
 // Define typedefs for convenience
 namespace pat {
   typedef std::vector<Electron> ElectronCollection;
@@ -62,6 +65,8 @@ namespace pat {
       Electron(const edm::RefToBase<reco::GsfElectron>& anElectronRef);
       /// constructor from a Ptr to a reco::GsfElectron
       Electron(const edm::Ptr<reco::GsfElectron>& anElectronRef);
+      /// constructor from Run3ScoutingElectron
+      Electron(const Run3ScoutingElectron& scoutingElectron);
       /// destructor
       ~Electron() override;
 
@@ -270,6 +275,29 @@ namespace pat {
         associatedPackedFCandidateIndices_.insert(associatedPackedFCandidateIndices_.end(), beginIndexItr, endIndexItr);
       }
 
+      // ---- Scouting flag ----
+      bool isScoutingElectron() const { return isScoutingElectron_; }
+
+      // ---- Universal accessors with scouting dispatch ----
+      // Track-related: dispatches to gsfTrack() for standard, scouting members for scouting
+      float trkEta() const;
+      float trkPhi() const;
+      float trkpMode() const;
+      float trketaMode() const;
+      float trkphiMode() const;
+      float trkqoverpModeError() const;
+
+      // ECAL crystal-level: dispatches to superCluster() for standard, scouting members for scouting
+      uint32_t seedId() const;
+      uint32_t nClusters() const;
+      uint32_t nCrystals() const;
+
+      // ---- Scouting-only accessors (no standard equivalent) ----
+      std::vector<float> const& scoutingEnergyMatrix() const { return scoutingEnergyMatrix_; }
+      std::vector<float> const& scoutingTimingMatrix() const { return scoutingTimingMatrix_; }
+      std::vector<uint32_t> const& scoutingDetIds() const { return scoutingDetIds_; }
+      bool scoutingRechitZeroSuppression() const { return scoutingRechitZeroSuppression_; }
+
       friend class pat::PATElectronSlimmer;
       friend class pat::PATElectronCandidatesRekeyer;
 
@@ -378,6 +406,22 @@ namespace pat {
       // ---- link to PackedPFCandidates
       edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
       std::vector<uint16_t> associatedPackedFCandidateIndices_;
+
+      // ---- scouting-specific members ----
+      bool isScoutingElectron_{false};
+      std::vector<float> scoutingTrkEta_;
+      std::vector<float> scoutingTrkPhi_;
+      std::vector<float> scoutingTrkpMode_;
+      std::vector<float> scoutingTrketaMode_;
+      std::vector<float> scoutingTrkphiMode_;
+      std::vector<float> scoutingTrkqoverpModeError_;
+      uint32_t scoutingSeedId_{0};
+      uint32_t scoutingNClusters_{0};
+      uint32_t scoutingNCrystals_{0};
+      std::vector<float> scoutingEnergyMatrix_;
+      std::vector<float> scoutingTimingMatrix_;
+      std::vector<uint32_t> scoutingDetIds_;
+      bool scoutingRechitZeroSuppression_{false};
     };
   }  // namespace io_v1
 }  // namespace pat

DataFormats/PatCandidates/interface/Jet.h

@@ -48,6 +48,9 @@
 
 #include <numeric>
 
+// Forward declaration for scouting
+class Run3ScoutingPFJet;
+
 // Define typedefs for convenience
 namespace pat {
   namespace io_v1 {
@@ -101,6 +104,8 @@ namespace pat {
       Jet(const edm::RefToBase<pat::Jet>& aJetRef);
       /// constructure from ref to pat::Jet
       Jet(const edm::Ptr<pat::Jet>& aJetRef);
+      /// constructor from Run3ScoutingPFJet
+      Jet(const Run3ScoutingPFJet& scoutingJet);
       /// destructor
       ~Jet() override;
       /// required reimplementation of the Candidate's clone method

DataFormats/PatCandidates/interface/Muon.h

@@ -25,13 +25,16 @@
 #include "DataFormats/MuonReco/interface/MuonTimeExtra.h"
 
 #include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/TrackReco/interface/HitPattern.h"
 #include "DataFormats/PatCandidates/interface/Lepton.h"
 #include "DataFormats/PatCandidates/interface/MuonFwd.h"
 #include "DataFormats/ParticleFlowCandidate/interface/IsolatedPFCandidateFwd.h"
 #include "DataFormats/ParticleFlowCandidate/interface/IsolatedPFCandidate.h"
 #include "DataFormats/MuonReco/interface/MuonSimInfo.h"
 
 // Define typedefs for convenience
+class Run3ScoutingMuon;
+
 namespace pat {
   typedef std::vector<Muon> MuonCollection;
   typedef edm::Ref<MuonCollection> MuonRef;
@@ -60,6 +63,8 @@ namespace pat {
       Muon(const edm::RefToBase<reco::Muon>& aMuonRef);
       /// constructor from a Ptr to a reco muon
       Muon(const edm::Ptr<reco::Muon>& aMuonRef);
+      /// constructor from a scouting muon
+      Muon(const Run3ScoutingMuon& aMuon);
       /// destructor
       ~Muon() override;
 
@@ -345,6 +350,46 @@ namespace pat {
       }
       bool triggered(const char* pathName) const { return triggerObjectMatchByPath(pathName, true, true) != nullptr; }
 
+      // ---- Methods that hide reco::Muon methods for scouting muon compatibility ----
+      // For ScoutingMuon, these return cached values; otherwise delegate to reco::Muon
+
+      /// Number of chambers (hides reco::Muon::numberOfChambers)
+      int numberOfChambers() const;
+      /// Number of chambers CSC or DT only (hides reco::Muon::numberOfChambersCSCorDT)
+      int numberOfChambersCSCorDT() const;
+      /// Number of muon stations with matches (hides reco::Muon::numberOfMatches)
+      int numberOfMatches(reco::Muon::ArbitrationType type = reco::Muon::SegmentAndTrackArbitration) const;
+      /// Number of matched stations (hides reco::Muon::numberOfMatchedStations)
+      int numberOfMatchedStations(reco::Muon::ArbitrationType type = reco::Muon::SegmentAndTrackArbitration) const;
+      /// Expected number of matched stations (hides reco::Muon::expectedNnumberOfMatchedStations)
+      unsigned int expectedNnumberOfMatchedStations(float minDistanceFromEdge = 10.0) const;
+      /// Muon station mask (hides reco::Muon::stationMask)
+      unsigned int stationMask(reco::Muon::ArbitrationType type = reco::Muon::SegmentAndTrackArbitration) const;
+      /// Number of matched RPC layers (hides reco::Muon::numberOfMatchedRPCLayers)
+      int numberOfMatchedRPCLayers(reco::Muon::ArbitrationType type = reco::Muon::RPCHitAndTrackArbitration) const;
+      /// RPC layer mask (hides reco::Muon::RPClayerMask)
+      unsigned int RPClayerMask(reco::Muon::ArbitrationType type = reco::Muon::RPCHitAndTrackArbitration) const;
+
+      // ---- Hit information accessors ----
+      // For scouting muons return cached values; for standard muons compute from tracks
+
+      /// Number of valid muon hits (from global track hitPattern for standard muons)
+      int numberOfValidMuonHits() const;
+      /// Number of valid standalone muon hits
+      int numberOfValidStandAloneMuonHits() const;
+      /// Number of standalone muon matched stations
+      int numberOfStandAloneMuonMatchedStations() const;
+      /// Number of valid pixel hits (from inner track hitPattern)
+      int numberOfValidPixelHits() const;
+      /// Number of valid strip hits (from inner track hitPattern)
+      int numberOfValidStripHits() const;
+      /// Number of pixel layers with measurement
+      int numberOfPixelLayersWithMeasurement() const;
+      /// Number of tracker layers with measurement
+      int numberOfTrackerLayersWithMeasurement() const;
+      /// Track hit pattern (from inner track for standard muons, from scouting data for scouting muons)
+      reco::HitPattern const& trkHitPattern() const;
+
     protected:
       // ---- for content embedding ----
 
@@ -440,6 +485,22 @@ namespace pat {
       float simEta_;
       float simPhi_;
       float simMatchQuality_;
+
+    private:
+      // ---- Cached values for scouting muons ----
+      // Filled by constructor from Run3ScoutingMuon; accessors check isScoutingMuon()
+      int scoutingNChambers_{0};
+      int scoutingNChambersCSCorDT_{0};
+      int scoutingNMatches_{0};
+      int scoutingNMatchedStations_{0};
+      unsigned int scoutingExpectedMatchedStations_{0};
+      unsigned int scoutingStationMask_{0};
+      int scoutingNMatchedRPCLayers_{0};
+      unsigned int scoutingRPCLayerMask_{0};
+      int scoutingNValidMuonHits_{0};
+      int scoutingNValidStandAloneMuonHits_{0};
+      int scoutingNStandAloneMuonMatchedStations_{0};
+      reco::HitPattern scoutingTrkHitPattern_;
     };
   }  // namespace io_v1
 }  // namespace pat

DataFormats/PatCandidates/interface/Photon.h

@@ -17,6 +17,7 @@
   \author   Steven Lowette, Giovanni Petrucciani, Frederic Ronga
 */
 
+#include <cstdint>
 #include "DataFormats/PatCandidates/interface/PATObject.h"
 #include "DataFormats/EgammaCandidates/interface/Photon.h"
 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
@@ -26,6 +27,9 @@
 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
 #include "DataFormats/Common/interface/AtomicPtrCache.h"
 
+// Forward declaration for scouting
+class Run3ScoutingPhoton;
+
 // Define typedefs for convenience
 namespace pat {
   namespace io_v1 {
@@ -60,6 +64,8 @@ namespace pat {
       Photon(const edm::RefToBase<reco::Photon>& aPhotonRef);
       /// constructor from a Ptr to a reco photon
       Photon(const edm::Ptr<reco::Photon>& aPhotonRef);
+      /// constructor from Run3ScoutingPhoton
+      Photon(const Run3ScoutingPhoton& scoutingPhoton);
       /// destructor
       ~Photon() override;
 
@@ -335,6 +341,21 @@ namespace pat {
       /// get the source candidate pointer with index i
       reco::CandidatePtr sourceCandidatePtr(size_type i) const override;
 
+      // ---- Scouting flag ----
+      bool isScoutingPhoton() const { return isScoutingPhoton_; }
+
+      // ---- Universal accessors with scouting dispatch ----
+      // ECAL crystal-level: dispatches to superCluster() for standard, scouting members for scouting
+      uint32_t seedId() const;
+      uint32_t nClusters() const;
+      uint32_t nCrystals() const;
+
+      // ---- Scouting-only accessors (no standard equivalent) ----
+      std::vector<float> const& scoutingEnergyMatrix() const { return scoutingEnergyMatrix_; }
+      std::vector<float> const& scoutingTimingMatrix() const { return scoutingTimingMatrix_; }
+      std::vector<uint32_t> const& scoutingDetIds() const { return scoutingDetIds_; }
+      bool scoutingRechitZeroSuppression() const { return scoutingRechitZeroSuppression_; }
+
       friend class pat::PATPhotonSlimmer;
       friend class pat::PATPhotonCandidatesRekeyer;
 
@@ -411,6 +432,16 @@ namespace pat {
       // ---- link to PackedPFCandidates
       edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
       std::vector<uint16_t> associatedPackedFCandidateIndices_;
+
+      // ---- scouting-specific members ----
+      bool isScoutingPhoton_{false};
+      uint32_t scoutingSeedId_{0};
+      uint32_t scoutingNClusters_{0};
+      uint32_t scoutingNCrystals_{0};
+      std::vector<float> scoutingEnergyMatrix_;
+      std::vector<float> scoutingTimingMatrix_;
+      std::vector<uint32_t> scoutingDetIds_;
+      bool scoutingRechitZeroSuppression_{false};
     };
   }  // namespace io_v1
 }  // namespace pat

DataFormats/PatCandidates/interface/ScoutingDataHandling.h

@@ -0,0 +1,28 @@
+#ifndef DataFormats_PatCandidates_ScoutingDataHandling_h
+#define DataFormats_PatCandidates_ScoutingDataHandling_h
+
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/VertexReco/interface/Vertex.h"
+#include "DataFormats/Scouting/interface/Run3ScoutingTrack.h"
+#include "DataFormats/PatCandidates/interface/Muon.h"
+#include "DataFormats/Scouting/interface/Run3ScoutingMuon.h"
+#include "DataFormats/Scouting/interface/Run3ScoutingVertex.h"
+
+namespace pat {
+  typedef reco::Candidate::LorentzVector LorentzVector;
+  typedef reco::Candidate::PolarLorentzVector PolarLorentzVector;
+
+  // Tracks
+  reco::Track makeRecoTrack(const Run3ScoutingTrack&);
+  reco::Track makeRecoTrack(const Run3ScoutingMuon&);
+  Run3ScoutingTrack makeScoutingTrack(const reco::Track&);
+  PolarLorentzVector makePolarLorentzVector(const Run3ScoutingTrack&, float mass);
+
+  // Muons
+  pat::Muon makePatMuon(const Run3ScoutingMuon&);
+
+  // Vertex
+  reco::Vertex makeRecoVertex(const Run3ScoutingVertex&);
+}  // namespace pat
+
+#endif