PFAnalysis Class Reference

Inheritance diagram for PFAnalysis:

Public Types
typedef ROOT::Math::Transform3D::Point	Point
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	beginRun (edm::Run const &iEvent, edm::EventSetup const &) override
void	endRun (edm::Run const &iEvent, edm::EventSetup const &) override
	PFAnalysis ()
	PFAnalysis (const edm::ParameterSet &)
	~PFAnalysis () override
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDAnalyzerBase () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	associateClusterToSimCluster (const vector< ElementWithIndex > &all_elements)
void	beginJob () override
void	clearVariables ()
void	endJob () override
GlobalPoint	getHitPosition (const DetId &id)
pair< vector< ElementWithIndex >, vector< tuple< int, int, float > > >	processBlocks (const std::vector< reco::PFBlock > &pfBlocks)
void	processTrackingParticles (const edm::View< TrackingParticle > &trackingParticles, edm::Handle< edm::View< TrackingParticle >> &trackingParticlesHandle)

Private Attributes
MagneticField const *	aField_
edm::EDGetTokenT< edm::View< CaloParticle > >	caloParticles_
vector< int >	element_charge_
vector< float >	element_deltap_
vector< float >	element_depth_
vector< float >	element_distance_d_
vector< int >	element_distance_i_
vector< int >	element_distance_j_
vector< float >	element_energy_
vector< float >	element_eta_
vector< float >	element_eta_ecal_
vector< float >	element_eta_hcal_
vector< int >	element_layer_
vector< float >	element_muon_csc_hits_
vector< float >	element_muon_dt_hits_
vector< float >	element_phi_
vector< float >	element_phi_ecal_
vector< float >	element_phi_hcal_
vector< float >	element_pt_
vector< float >	element_px_
vector< float >	element_py_
vector< float >	element_pz_
vector< float >	element_sigmadeltap_
vector< pair< int, int > >	element_to_candidate
vector< float >	element_trajpoint_
vector< int >	element_type_
edm::EventNumber_t	ev_event_
edm::LuminosityBlockNumber_t	ev_lumi_
edm::RunNumber_t	ev_run_
vector< int >	gen_charge_
vector< vector< int > >	gen_daughters_
vector< float >	gen_energy_
vector< float >	gen_eta_
vector< int >	gen_pdgid_
vector< float >	gen_phi_
vector< float >	gen_pt_
vector< float >	gen_px_
vector< float >	gen_py_
vector< float >	gen_pz_
vector< int >	gen_status_
edm::EDGetTokenT< std::vector< reco::GenParticle > >	genParticles_
CaloGeometry *	geom
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometryToken_
HcalTopology *	hcal_topo
edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord >	hcalDDDrecToken_
const HcalDDDRecConstants *	hcons
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magFieldToken_
edm::EDGetTokenT< std::vector< reco::PFBlock > >	pfBlocks_
vector< float >	pfcandidate_energy_
vector< float >	pfcandidate_eta_
vector< int >	pfcandidate_pdgid_
vector< float >	pfcandidate_phi_
vector< float >	pfcandidate_pt_
vector< float >	pfcandidate_px_
vector< float >	pfcandidate_py_
vector< float >	pfcandidate_pz_
edm::EDGetTokenT< std::vector< reco::PFCandidate > >	pfCandidates_
vector< float >	rechit_det_
vector< uint64_t >	rechit_detid_
vector< float >	rechit_e_
vector< float >	rechit_eta_
vector< int >	rechit_idx_element_
vector< float >	rechit_phi_
vector< float >	rechit_subdet_
vector< float >	rechit_x_
vector< float >	rechit_y_
vector< float >	rechit_z_
bool	saveHits
vector< int >	simcluster_bx_
vector< std::map< uint64_t, double > >	simcluster_detids_
vector< float >	simcluster_energy_
vector< float >	simcluster_eta_
vector< int >	simcluster_ev_
vector< int >	simcluster_idx_trackingparticle_
vector< int >	simcluster_nhits_
vector< float >	simcluster_phi_
vector< int >	simcluster_pid_
vector< float >	simcluster_pt_
vector< float >	simcluster_px_
vector< float >	simcluster_py_
vector< float >	simcluster_pz_
vector< pair< int, int > >	simcluster_to_element
vector< float >	simcluster_to_element_cmp
vector< int >	simhit_det_
vector< uint64_t >	simhit_detid_
vector< float >	simhit_eta_
vector< float >	simhit_frac_
vector< int >	simhit_idx_simcluster_
vector< float >	simhit_phi_
vector< int >	simhit_subdet_
vector< float >	simhit_x_
vector< float >	simhit_y_
vector< float >	simhit_z_
vector< int >	simtrack_idx_simcluster_
vector< int >	simtrack_pid_
vector< float >	simtrack_x_
vector< float >	simtrack_y_
vector< float >	simtrack_z_
TTree *	t_
edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	topologyToken_
vector< int >	trackingparticle_bx_
vector< float >	trackingparticle_dvx_
vector< float >	trackingparticle_dvy_
vector< float >	trackingparticle_dvz_
vector< float >	trackingparticle_energy_
vector< float >	trackingparticle_eta_
vector< int >	trackingparticle_ev_
vector< float >	trackingparticle_exx_
vector< float >	trackingparticle_exy_
vector< int >	trackingparticle_mother_
vector< float >	trackingparticle_ovx_
vector< float >	trackingparticle_ovy_
vector< float >	trackingparticle_ovz_
vector< float >	trackingparticle_phi_
vector< int >	trackingparticle_pid_
vector< float >	trackingparticle_pt_
vector< float >	trackingparticle_px_
vector< float >	trackingparticle_py_
vector< float >	trackingparticle_pz_
vector< pair< int, int > >	trackingparticle_to_element
edm::EDGetTokenT< edm::View< TrackingParticle > >	trackingParticles_
edm::EDGetTokenT< edm::View< reco::Track > >	tracks_
edm::EDGetTokenT< reco::RecoToSimCollection >	tracks_recotosim_

Additional Inherited Members
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 108 of file PFAnalysisNtuplizer.cc.

Member Typedef Documentation

Point

typedef ROOT::Math::Transform3D::Point PFAnalysis::Point

Definition at line 110 of file PFAnalysisNtuplizer.cc.

Constructor & Destructor Documentation

PFAnalysis() [1/2]

PFAnalysis::PFAnalysis

(

)

Definition at line 280 of file PFAnalysisNtuplizer.cc.

{ ; }

PFAnalysis() [2/2]

PFAnalysis::PFAnalysis ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 282 of file PFAnalysisNtuplizer.cc.

                                                     {
  tracks_recotosim_ = consumes<reco::RecoToSimCollection>(edm::InputTag("trackingParticleRecoTrackAsssociation"));
  trackingParticles_ = consumes<edm::View<TrackingParticle>>(edm::InputTag("mix", "MergedTrackTruth"));
  caloParticles_ = consumes<edm::View<CaloParticle>>(edm::InputTag("mix", "MergedCaloTruth"));
  genParticles_ = consumes<std::vector<reco::GenParticle>>(edm::InputTag("genParticles"));
  pfBlocks_ = consumes<std::vector<reco::PFBlock>>(edm::InputTag("particleFlowBlock"));
  pfCandidates_ = consumes<std::vector<reco::PFCandidate>>(edm::InputTag("particleFlow"));
  tracks_ = consumes<edm::View<reco::Track>>(edm::InputTag("generalTracks"));
  saveHits = iConfig.getUntrackedParameter<bool>("saveHits", false);
 
  geometryToken_ = esConsumes<CaloGeometry, CaloGeometryRecord>(edm::ESInputTag{});
  topologyToken_ = esConsumes<HcalTopology, HcalRecNumberingRecord>(edm::ESInputTag{});
  magFieldToken_ = esConsumes<edm::Transition::BeginRun>();
  hcalDDDrecToken_ = esConsumes<edm::Transition::BeginRun>();
 
  usesResource(TFileService::kSharedResource);
  edm::Service<TFileService> fs;
  fs->make<TH1F>("total", "total", 100, 0, 5.);
 
  t_ = fs->make<TTree>("pftree", "pftree");
 
  // event info
  t_->Branch("event", &ev_event_);
  t_->Branch("lumi", &ev_lumi_);
  t_->Branch("run", &ev_run_);
 
  t_->Branch("trackingparticle_eta", &trackingparticle_eta_);
  t_->Branch("trackingparticle_phi", &trackingparticle_phi_);
  t_->Branch("trackingparticle_pt", &trackingparticle_pt_);
  t_->Branch("trackingparticle_px", &trackingparticle_px_);
  t_->Branch("trackingparticle_py", &trackingparticle_py_);
  t_->Branch("trackingparticle_pz", &trackingparticle_pz_);
  t_->Branch("trackingparticle_energy", &trackingparticle_energy_);
  t_->Branch("trackingparticle_dvx", &trackingparticle_dvx_);
  t_->Branch("trackingparticle_dvy", &trackingparticle_dvy_);
  t_->Branch("trackingparticle_dvz", &trackingparticle_dvz_);
  t_->Branch("trackingparticle_bx", &trackingparticle_bx_);
  t_->Branch("trackingparticle_ev", &trackingparticle_ev_);
  t_->Branch("trackingparticle_pid", &trackingparticle_pid_);
 
  t_->Branch("simcluster_eta", &simcluster_eta_);
  t_->Branch("simcluster_phi", &simcluster_phi_);
  t_->Branch("simcluster_pt", &simcluster_pt_);
  t_->Branch("simcluster_px", &simcluster_px_);
  t_->Branch("simcluster_py", &simcluster_py_);
  t_->Branch("simcluster_pz", &simcluster_pz_);
  t_->Branch("simcluster_energy", &simcluster_energy_);
  t_->Branch("simcluster_bx", &simcluster_bx_);
  t_->Branch("simcluster_ev", &simcluster_ev_);
  t_->Branch("simcluster_pid", &simcluster_pid_);
  t_->Branch("simcluster_idx_trackingparticle", &simcluster_idx_trackingparticle_);
  t_->Branch("simcluster_nhits", &simcluster_nhits_);
 
  if (saveHits) {
    t_->Branch("simhit_frac", &simhit_frac_);
    t_->Branch("simhit_x", &simhit_x_);
    t_->Branch("simhit_y", &simhit_y_);
    t_->Branch("simhit_z", &simhit_z_);
    t_->Branch("simhit_det", &simhit_det_);
    t_->Branch("simhit_subdet", &simhit_subdet_);
    t_->Branch("simhit_eta", &simhit_eta_);
    t_->Branch("simhit_phi", &simhit_phi_);
    t_->Branch("simhit_idx_simcluster", &simhit_idx_simcluster_);
    t_->Branch("simhit_detid", &simhit_detid_);
 
    t_->Branch("rechit_e", &rechit_e_);
    t_->Branch("rechit_x", &rechit_x_);
    t_->Branch("rechit_y", &rechit_y_);
    t_->Branch("rechit_z", &rechit_z_);
    t_->Branch("rechit_det", &rechit_det_);
    t_->Branch("rechit_subdet", &rechit_subdet_);
    t_->Branch("rechit_eta", &rechit_eta_);
    t_->Branch("rechit_phi", &rechit_phi_);
    t_->Branch("rechit_idx_element", &rechit_idx_element_);
    t_->Branch("rechit_detid", &rechit_detid_);
  }
 
  t_->Branch("simtrack_x", &simtrack_x_);
  t_->Branch("simtrack_y", &simtrack_y_);
  t_->Branch("simtrack_z", &simtrack_z_);
  t_->Branch("simtrack_idx_simcluster_", &simtrack_idx_simcluster_);
  t_->Branch("simtrack_pid", &simtrack_pid_);
 
  t_->Branch("gen_eta", &gen_eta_);
  t_->Branch("gen_phi", &gen_phi_);
  t_->Branch("gen_pt", &gen_pt_);
  t_->Branch("gen_px", &gen_px_);
  t_->Branch("gen_py", &gen_py_);
  t_->Branch("gen_pz", &gen_pz_);
  t_->Branch("gen_energy", &gen_energy_);
  t_->Branch("gen_charge", &gen_charge_);
  t_->Branch("gen_pdgid", &gen_pdgid_);
  t_->Branch("gen_status", &gen_status_);
  t_->Branch("gen_daughters", &gen_daughters_);
 
  //PF Elements
  t_->Branch("element_pt", &element_pt_);
  t_->Branch("element_px", &element_px_);
  t_->Branch("element_py", &element_py_);
  t_->Branch("element_pz", &element_pz_);
  t_->Branch("element_deltap", &element_deltap_);
  t_->Branch("element_sigmadeltap", &element_sigmadeltap_);
  t_->Branch("element_eta", &element_eta_);
  t_->Branch("element_phi", &element_phi_);
  t_->Branch("element_energy", &element_energy_);
  t_->Branch("element_eta_ecal", &element_eta_ecal_);
  t_->Branch("element_phi_ecal", &element_phi_ecal_);
  t_->Branch("element_eta_hcal", &element_eta_hcal_);
  t_->Branch("element_phi_hcal", &element_phi_hcal_);
  t_->Branch("element_charge", &element_charge_);
  t_->Branch("element_type", &element_type_);
  t_->Branch("element_layer", &element_layer_);
  t_->Branch("element_depth", &element_depth_);
  t_->Branch("element_trajpoint", &element_trajpoint_);
  t_->Branch("element_muon_dt_hits", &element_muon_dt_hits_);
  t_->Branch("element_muon_csc_hits", &element_muon_csc_hits_);
 
  //Distance matrix between PF elements
  t_->Branch("element_distance_i", &element_distance_i_);
  t_->Branch("element_distance_j", &element_distance_j_);
  t_->Branch("element_distance_d", &element_distance_d_);
 
  t_->Branch("pfcandidate_eta", &pfcandidate_eta_);
  t_->Branch("pfcandidate_phi", &pfcandidate_phi_);
  t_->Branch("pfcandidate_pt", &pfcandidate_pt_);
  t_->Branch("pfcandidate_px", &pfcandidate_px_);
  t_->Branch("pfcandidate_py", &pfcandidate_py_);
  t_->Branch("pfcandidate_pz", &pfcandidate_pz_);
  t_->Branch("pfcandidate_energy", &pfcandidate_energy_);
  t_->Branch("pfcandidate_pdgid", &pfcandidate_pdgid_);
 
  //Links between reco, gen and PFCandidate objects
  t_->Branch("trackingparticle_to_element", &trackingparticle_to_element);
  t_->Branch("simcluster_to_element", &simcluster_to_element);
  t_->Branch("simcluster_to_element_cmp", &simcluster_to_element_cmp);
  t_->Branch("element_to_candidate", &element_to_candidate);
}  // constructor

References edm::ParameterSet::getUntrackedParameter(), HLT_FULL_cff::InputTag, TFileService::kSharedResource, and TFileService::make().

~PFAnalysis()

PFAnalysis::~PFAnalysis ( )

override

Definition at line 420 of file PFAnalysisNtuplizer.cc.

{}

Member Function Documentation

analyze()

void PFAnalysis::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 562 of file PFAnalysisNtuplizer.cc.

                                                                            {
  clearVariables();
 
  auto& pG = iSetup.getData(geometryToken_);
  geom = (CaloGeometry*)&pG;
  auto& pT = iSetup.getData(topologyToken_);
  hcal_topo = (HcalTopology*)&pT;
 
  //Simulated tracks, cleaned up by TrackingTruthAccumulator
  edm::Handle<edm::View<TrackingParticle>> trackingParticlesHandle;
  iEvent.getByToken(trackingParticles_, trackingParticlesHandle);
  const edm::View<TrackingParticle>& trackingParticles = *trackingParticlesHandle;
 
  edm::Handle<edm::View<CaloParticle>> caloParticlesHandle;
  iEvent.getByToken(caloParticles_, caloParticlesHandle);
  const edm::View<CaloParticle>& caloParticles = *caloParticlesHandle;
 
  //Matches reco tracks to sim tracks (TrackingParticle)
  edm::Handle<reco::RecoToSimCollection> recotosimCollection;
  iEvent.getByToken(tracks_recotosim_, recotosimCollection);
  const auto recotosim = *recotosimCollection;
 
  edm::Handle<edm::View<reco::Track>> trackHandle;
  iEvent.getByToken(tracks_, trackHandle);
  const edm::View<reco::Track>& tracks = *trackHandle;
 
  edm::Handle<std::vector<reco::GenParticle>> genParticlesHandle;
  iEvent.getByToken(genParticles_, genParticlesHandle);
  for (std::vector<reco::GenParticle>::const_iterator it_p = genParticlesHandle->begin();
       it_p != genParticlesHandle->end();
       ++it_p) {
    gen_eta_.push_back(it_p->eta());
    gen_phi_.push_back(it_p->phi());
    gen_pt_.push_back(it_p->pt());
    gen_px_.push_back(it_p->px());
    gen_py_.push_back(it_p->py());
    gen_pz_.push_back(it_p->pz());
    gen_energy_.push_back(it_p->energy());
    gen_charge_.push_back(it_p->charge());
    gen_pdgid_.push_back(it_p->pdgId());
    gen_status_.push_back(it_p->status());
    std::vector<int> daughters(it_p->daughterRefVector().size(), 0);
    for (unsigned j = 0; j < it_p->daughterRefVector().size(); ++j) {
      daughters[j] = static_cast<int>(it_p->daughterRefVector().at(j).key());
    }
    gen_daughters_.push_back(daughters);
  }
 
  edm::Handle<std::vector<reco::PFCandidate>> pfCandidatesHandle;
  iEvent.getByToken(pfCandidates_, pfCandidatesHandle);
  std::vector<reco::PFCandidate> pfCandidates = *pfCandidatesHandle;
 
  edm::Handle<std::vector<reco::PFBlock>> pfBlocksHandle;
  iEvent.getByToken(pfBlocks_, pfBlocksHandle);
  std::vector<reco::PFBlock> pfBlocks = *pfBlocksHandle;
 
  //Collect all clusters, tracks and superclusters
  const auto& all_elements_distances = processBlocks(pfBlocks);
  const auto& all_elements = all_elements_distances.first;
  const auto& all_distances = all_elements_distances.second;
  assert(!all_elements.empty());
  //assert(all_distances.size() > 0);
  for (const auto& d : all_distances) {
    element_distance_i_.push_back(get<0>(d));
    element_distance_j_.push_back(get<1>(d));
    element_distance_d_.push_back(get<2>(d));
  }
 
  //We need to use the original reco::Track collection for track association
  for (unsigned long ntrack = 0; ntrack < tracks.size(); ntrack++) {
    edm::RefToBase<reco::Track> trackref(trackHandle, ntrack);
    const auto vec_idx_in_all_elements = find_element_ref(all_elements, trackref);
 
    //track was not used by PF, we skip as well
    if (vec_idx_in_all_elements.empty()) {
      continue;
    }
 
    if (recotosim.find(trackref) != recotosim.end()) {
      const auto& tps = recotosim[trackref];
      for (const auto& tp : tps) {
        edm::Ref<std::vector<TrackingParticle>> tpr = tp.first;
        for (auto idx_in_all_elements : vec_idx_in_all_elements) {
          trackingparticle_to_element.emplace_back(tpr.key(), idx_in_all_elements);
        }
      }
    }
  }
 
  processTrackingParticles(trackingParticles, trackingParticlesHandle);
 
  int idx_simcluster = 0;
  //Fill genparticles from calorimeter hits
  for (unsigned long ncaloparticle = 0; ncaloparticle < caloParticles.size(); ncaloparticle++) {
    const auto& cp = caloParticles.at(ncaloparticle);
    edm::RefToBase<CaloParticle> cpref(caloParticlesHandle, ncaloparticle);
 
    int nhits = 0;
    for (const auto& simcluster : cp.simClusters()) {
      //create a map of detId->energy of all the rechits in all the clusters of this SimCluster
      map<uint64_t, double> detid_energy;
 
      simcluster_nhits_.push_back(nhits);
      simcluster_eta_.push_back(simcluster->p4().eta());
      simcluster_phi_.push_back(simcluster->p4().phi());
      simcluster_pt_.push_back(simcluster->p4().pt());
      simcluster_energy_.push_back(simcluster->energy());
      simcluster_pid_.push_back(simcluster->pdgId());
      simcluster_bx_.push_back(simcluster->eventId().bunchCrossing());
      simcluster_ev_.push_back(simcluster->eventId().event());
 
      simcluster_px_.push_back(simcluster->p4().x());
      simcluster_py_.push_back(simcluster->p4().y());
      simcluster_pz_.push_back(simcluster->p4().z());
 
      for (const auto& hf : simcluster->hits_and_fractions()) {
        DetId id(hf.first);
 
        if (id.det() == DetId::Hcal || id.det() == DetId::Ecal) {
          const auto& pos = getHitPosition(id);
          nhits += 1;
 
          const float x = pos.x();
          const float y = pos.y();
          const float z = pos.z();
          const float eta = pos.eta();
          const float phi = pos.phi();
 
          simhit_frac_.push_back(hf.second);
          simhit_x_.push_back(x);
          simhit_y_.push_back(y);
          simhit_z_.push_back(z);
          simhit_det_.push_back(id.det());
          simhit_subdet_.push_back(id.subdetId());
          simhit_eta_.push_back(eta);
          simhit_phi_.push_back(phi);
          simhit_idx_simcluster_.push_back(idx_simcluster);
          simhit_detid_.push_back(id.rawId());
          detid_energy[id.rawId()] += hf.second;
        }
      }
 
      int simcluster_to_trackingparticle = -1;
      for (const auto& simtrack : simcluster->g4Tracks()) {
        simtrack_x_.push_back(simtrack.trackerSurfacePosition().x());
        simtrack_y_.push_back(simtrack.trackerSurfacePosition().y());
        simtrack_z_.push_back(simtrack.trackerSurfacePosition().z());
        simtrack_idx_simcluster_.push_back(idx_simcluster);
        simtrack_pid_.push_back(simtrack.type());
 
        for (unsigned int itp = 0; itp < trackingParticles.size(); itp++) {
          const auto& simtrack2 = trackingParticles.at(itp).g4Tracks().at(0);
          //compare the two tracks, taking into account that both eventId and trackId need to be compared due to pileup
          if (simtrack.eventId() == simtrack2.eventId() && simtrack.trackId() == simtrack2.trackId()) {
            simcluster_to_trackingparticle = itp;
            //we are satisfied with the first match, in practice there should not be more
            break;
          }
        }  //trackingParticles
      }    //simcluster tracks
 
      simcluster_detids_.push_back(detid_energy);
      simcluster_idx_trackingparticle_.push_back(simcluster_to_trackingparticle);
 
      idx_simcluster += 1;
    }  //simclusters
  }    //caloParticles
 
  associateClusterToSimCluster(all_elements);
 
  //fill elements
  for (unsigned int ielem = 0; ielem < all_elements.size(); ielem++) {
    const auto& elem = all_elements.at(ielem);
    const auto& orig = elem.orig;
    reco::PFBlockElement::Type type = orig.type();
 
    float pt = 0.0;
    float deltap = 0.0;
    float sigmadeltap = 0.0;
    float px = 0.0;
    float py = 0.0;
    float pz = 0.0;
    float eta = 0.0;
    float phi = 0.0;
    float energy = 0.0;
    float trajpoint = 0.0;
    float eta_ecal = 0.0;
    float phi_ecal = 0.0;
    float eta_hcal = 0.0;
    float phi_hcal = 0.0;
    int charge = 0;
    int layer = 0;
    float depth = 0;
    float muon_dt_hits = 0.0;
    float muon_csc_hits = 0.0;
 
    if (type == reco::PFBlockElement::TRACK) {
      const auto& matched_pftrack = orig.trackRefPF();
      if (matched_pftrack.isNonnull()) {
        const auto& atECAL = matched_pftrack->extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax);
        const auto& atHCAL = matched_pftrack->extrapolatedPoint(reco::PFTrajectoryPoint::HCALEntrance);
        if (atHCAL.isValid()) {
          eta_hcal = atHCAL.positionREP().eta();
          phi_hcal = atHCAL.positionREP().phi();
        }
        if (atECAL.isValid()) {
          eta_ecal = atECAL.positionREP().eta();
          phi_ecal = atECAL.positionREP().phi();
        }
      }
      const auto& ref = ((const reco::PFBlockElementTrack*)&orig)->trackRef();
      pt = ref->pt();
      px = ref->px();
      py = ref->py();
      pz = ref->pz();
      eta = ref->eta();
      phi = ref->phi();
      energy = ref->p();
      charge = ref->charge();
 
      reco::MuonRef muonRef = orig.muonRef();
      if (muonRef.isNonnull()) {
        reco::TrackRef standAloneMu = muonRef->standAloneMuon();
        if (standAloneMu.isNonnull()) {
          muon_dt_hits = standAloneMu->hitPattern().numberOfValidMuonDTHits();
          muon_csc_hits = standAloneMu->hitPattern().numberOfValidMuonCSCHits();
        }
      }
 
    } else if (type == reco::PFBlockElement::BREM) {
      const auto* orig2 = (const reco::PFBlockElementBrem*)&orig;
      const auto& ref = orig2->GsftrackRef();
      if (ref.isNonnull()) {
        deltap = orig2->DeltaP();
        sigmadeltap = orig2->SigmaDeltaP();
        pt = ref->pt();
        px = ref->px();
        py = ref->py();
        pz = ref->pz();
        eta = ref->eta();
        phi = ref->phi();
        energy = ref->p();
        trajpoint = orig2->indTrajPoint();
        charge = ref->charge();
      }
    } else if (type == reco::PFBlockElement::GSF) {
      //requires to keep GsfPFRecTracks
      const auto* orig2 = (const reco::PFBlockElementGsfTrack*)&orig;
      const auto& vec = orig2->Pin();
      pt = vec.pt();
      px = vec.px();
      py = vec.py();
      pz = vec.pz();
      eta = vec.eta();
      phi = vec.phi();
      energy = vec.energy();
      if (!orig2->GsftrackRefPF().isNull()) {
        charge = orig2->GsftrackRefPF()->charge();
      }
    } else if (type == reco::PFBlockElement::ECAL || type == reco::PFBlockElement::PS1 ||
               type == reco::PFBlockElement::PS2 || type == reco::PFBlockElement::HCAL ||
               type == reco::PFBlockElement::HO || type == reco::PFBlockElement::HFHAD ||
               type == reco::PFBlockElement::HFEM) {
      const auto& ref = ((const reco::PFBlockElementCluster*)&orig)->clusterRef();
      if (ref.isNonnull()) {
        eta = ref->eta();
        phi = ref->phi();
        px = ref->position().x();
        py = ref->position().y();
        pz = ref->position().z();
        energy = ref->energy();
        layer = ref->layer();
        depth = ref->depth();
      }
    } else if (type == reco::PFBlockElement::SC) {
      const auto& clref = ((const reco::PFBlockElementSuperCluster*)&orig)->superClusterRef();
      if (clref.isNonnull()) {
        eta = clref->eta();
        phi = clref->phi();
        px = clref->position().x();
        py = clref->position().y();
        pz = clref->position().z();
        energy = clref->energy();
      }
    }
    vector<int> tps;
    for (const auto& t : trackingparticle_to_element) {
      if (t.second == (int)ielem) {
        tps.push_back(t.first);
      }
    }
    vector<int> scs;
    for (const auto& t : simcluster_to_element) {
      if (t.second == (int)ielem) {
        scs.push_back(t.first);
      }
    }
 
    element_pt_.push_back(pt);
    element_px_.push_back(px);
    element_py_.push_back(py);
    element_pz_.push_back(pz);
    element_deltap_.push_back(deltap);
    element_sigmadeltap_.push_back(sigmadeltap);
    element_eta_.push_back(eta);
    element_phi_.push_back(phi);
    element_energy_.push_back(energy);
    element_eta_ecal_.push_back(eta_ecal);
    element_phi_ecal_.push_back(phi_ecal);
    element_eta_hcal_.push_back(eta_hcal);
    element_phi_hcal_.push_back(phi_hcal);
    element_charge_.push_back(charge);
    element_type_.push_back(type);
    element_layer_.push_back(layer);
    element_depth_.push_back(depth);
    element_trajpoint_.push_back(trajpoint);
    element_muon_dt_hits_.push_back(muon_dt_hits);
    element_muon_csc_hits_.push_back(muon_csc_hits);
  }
 
  //associate candidates to elements
  int icandidate = 0;
  for (const auto& cand : pfCandidates) {
    pfcandidate_eta_.push_back(cand.eta());
    pfcandidate_phi_.push_back(cand.phi());
    pfcandidate_pt_.push_back(cand.pt());
    pfcandidate_px_.push_back(cand.px());
    pfcandidate_py_.push_back(cand.py());
    pfcandidate_pz_.push_back(cand.pz());
    pfcandidate_energy_.push_back(cand.energy());
    pfcandidate_pdgid_.push_back(cand.pdgId());
 
    for (const auto& el : cand.elementsInBlocks()) {
      const auto idx_block = el.first.index();
      unsigned idx_element_in_block = el.second;
 
      int ielem = -1;
      for (const auto& elem_with_index : all_elements) {
        ielem += 1;
        if (elem_with_index.idx_block == idx_block && elem_with_index.idx_elem == idx_element_in_block) {
          break;
        }
      }
      assert(ielem != -1);
      element_to_candidate.push_back(make_pair(ielem, icandidate));
    }  //elements
 
    icandidate += 1;
  }  //pfCandidates
 
  ev_event_ = iEvent.id().event();
  ev_lumi_ = iEvent.id().luminosityBlock();
  ev_run_ = iEvent.id().run();
 
  t_->Fill();
}  //analyze

References cms::cuda::assert(), reco::PFBlockElement::BREM, caloTruthCellsProducer_cfi::caloParticles, ALCARECOTkAlJpsiMuMu_cff::charge, ztail::d, BPhysicsValidation_cfi::daughters, LEDCalibrationChannels::depth, DetId::Ecal, reco::PFBlockElement::ECAL, reco::PFTrajectoryPoint::ECALShowerMax, HCALHighEnergyHPDFilter_cfi::energy, PVValHelper::eta, find_element_ref(), relativeConstraints::geom, edm::EventSetup::getData(), reco::PFBlockElement::GSF, DetId::Hcal, reco::PFBlockElement::HCAL, reco::PFTrajectoryPoint::HCALEntrance, photonIsolationHIProducer_cfi::hf, reco::PFBlockElement::HFEM, reco::PFBlockElement::HFHAD, reco::PFBlockElement::HO, triggerObjects_cff::id, iEvent, edm::Ref< C, T, F >::isNonnull(), dqmiolumiharvest::j, edm::Ref< C, T, F >::key(), phase1PixelTopology::layer, nhits, ntrack, zmumugammaAnalyzer_cfi::pfCandidates, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, DiDispStaMuonMonitor_cfi::pt, PVValHelper::pT, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, reco::PFBlockElement::SC, submitPVValidationJobs::t, cmsswSequenceInfo::tp, reco::PFBlockElement::TRACK, muonClassificationByHits_cfi::trackingParticles, and tracks.

associateClusterToSimCluster()

void PFAnalysis::associateClusterToSimCluster ( const vector< ElementWithIndex > &  all_elements )

private

Definition at line 998 of file PFAnalysisNtuplizer.cc.

                                                                                          {
  vector<map<uint64_t, double>> detids_elements;
  map<uint64_t, double> rechits_energy_all;
 
  int idx_element = 0;
  for (const auto& elem : all_elements) {
    map<uint64_t, double> detids;
    const auto& type = elem.orig.type();
 
    if (type == reco::PFBlockElement::ECAL || type == reco::PFBlockElement::HCAL || type == reco::PFBlockElement::PS1 ||
        type == reco::PFBlockElement::PS2 || type == reco::PFBlockElement::HO || type == reco::PFBlockElement::HFHAD ||
        type == reco::PFBlockElement::HFEM) {
      const auto& clref = elem.orig.clusterRef();
      assert(clref.isNonnull());
      const auto& cluster = *clref;
 
      //all rechits and the energy fractions in this cluster
      const vector<reco::PFRecHitFraction>& rechit_fracs = cluster.recHitFractions();
      for (const auto& rh : rechit_fracs) {
        const reco::PFRecHit pfrh = *rh.recHitRef();
        if (detids.find(pfrh.detId()) != detids.end()) {
          continue;
        }
        detids[pfrh.detId()] += pfrh.energy() * rh.fraction();
        const auto id = DetId(pfrh.detId());
        float x = 0;
        float y = 0;
        float z = 0;
        float eta = 0;
        float phi = 0;
 
        const auto& pos = getHitPosition(id);
        x = pos.x();
        y = pos.y();
        z = pos.z();
        eta = pos.eta();
        phi = pos.phi();
 
        rechit_x_.push_back(x);
        rechit_y_.push_back(y);
        rechit_z_.push_back(z);
        rechit_det_.push_back(id.det());
        rechit_subdet_.push_back(id.subdetId());
        rechit_eta_.push_back(eta);
        rechit_phi_.push_back(phi);
        rechit_e_.push_back(pfrh.energy() * rh.fraction());
        rechit_idx_element_.push_back(idx_element);
        rechit_detid_.push_back(id.rawId());
        rechits_energy_all[id.rawId()] += pfrh.energy() * rh.fraction();
      }  //rechit_fracs
    } else if (type == reco::PFBlockElement::SC) {
      const auto& clref = ((const reco::PFBlockElementSuperCluster*)&(elem.orig))->superClusterRef();
      assert(clref.isNonnull());
      const auto& cluster = *clref;
 
      //all rechits and the energy fractions in this cluster
      const auto& rechit_fracs = cluster.hitsAndFractions();
      for (const auto& rh : rechit_fracs) {
        if (detids.find(rh.first.rawId()) != detids.end()) {
          continue;
        }
        detids[rh.first.rawId()] += cluster.energy() * rh.second;
        const auto id = rh.first;
        float x = 0;
        float y = 0;
        float z = 0;
        float eta = 0;
        float phi = 0;
 
        const auto& pos = getHitPosition(id);
        x = pos.x();
        y = pos.y();
        z = pos.z();
        eta = pos.eta();
        phi = pos.phi();
 
        rechit_x_.push_back(x);
        rechit_y_.push_back(y);
        rechit_z_.push_back(z);
        rechit_det_.push_back(id.det());
        rechit_subdet_.push_back(id.subdetId());
        rechit_eta_.push_back(eta);
        rechit_phi_.push_back(phi);
        rechit_e_.push_back(rh.second);
        rechit_idx_element_.push_back(idx_element);
        rechit_detid_.push_back(id.rawId());
        rechits_energy_all[id.rawId()] += cluster.energy() * rh.second;
      }  //rechit_fracs
    }
    detids_elements.push_back(detids);
    idx_element += 1;
  }  //all_elements
 
  //associate elements (reco clusters) to simclusters
  int ielement = 0;
  for (const auto& detids : detids_elements) {
    int isimcluster = 0;
    if (!detids.empty()) {
      double sum_e_tot = 0.0;
      for (const auto& c : detids) {
        sum_e_tot += c.second;
      }
 
      for (const auto& simcluster_detids : simcluster_detids_) {
        double sum_e_tot_sc = 0.0;
        for (const auto& c : simcluster_detids) {
          sum_e_tot_sc += c.second;
        }
 
        //get the energy of the simcluster hits that matches detids of the rechits
        double cmp = detid_compare(detids, simcluster_detids);
        if (cmp > 0) {
          simcluster_to_element.push_back(make_pair(isimcluster, ielement));
          simcluster_to_element_cmp.push_back((float)cmp);
        }
        isimcluster += 1;
      }
    }  //element had rechits
    ielement += 1;
  }  //rechit clusters
}

References cms::cuda::assert(), c, fileCollector::cmp, reco::PFRecHit::detId(), detid_compare(), reco::PFBlockElement::ECAL, reco::PFRecHit::energy(), PVValHelper::eta, reco::PFBlockElement::HCAL, reco::PFBlockElement::HFEM, reco::PFBlockElement::HFHAD, reco::PFBlockElement::HO, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, and reco::PFBlockElement::SC.

beginJob()

void PFAnalysis::beginJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1127 of file PFAnalysisNtuplizer.cc.

{ ; }

beginRun()

void PFAnalysis::beginRun ( edm::Run const &  iEvent, edm::EventSetup const &  es  )

override

Definition at line 1120 of file PFAnalysisNtuplizer.cc.

                                                                       {
  hcons = &es.getData(hcalDDDrecToken_);
  aField_ = &es.getData(magFieldToken_);
}

References edm::EventSetup::getData().

clearVariables()

void PFAnalysis::clearVariables ( )

private

Definition at line 422 of file PFAnalysisNtuplizer.cc.

                                {
  ev_run_ = 0;
  ev_lumi_ = 0;
  ev_event_ = 0;
 
  trackingparticle_to_element.clear();
  simcluster_to_element.clear();
  simcluster_to_element_cmp.clear();
  element_to_candidate.clear();
 
  trackingparticle_eta_.clear();
  trackingparticle_phi_.clear();
  trackingparticle_pt_.clear();
  trackingparticle_px_.clear();
  trackingparticle_py_.clear();
  trackingparticle_pz_.clear();
  trackingparticle_energy_.clear();
  trackingparticle_dvx_.clear();
  trackingparticle_dvy_.clear();
  trackingparticle_dvz_.clear();
  trackingparticle_bx_.clear();
  trackingparticle_ev_.clear();
  trackingparticle_ovx_.clear();
  trackingparticle_ovy_.clear();
  trackingparticle_ovz_.clear();
  trackingparticle_exx_.clear();
  trackingparticle_exy_.clear();
  trackingparticle_mother_.clear();
  trackingparticle_pid_.clear();
 
  simcluster_eta_.clear();
  simcluster_phi_.clear();
  simcluster_pt_.clear();
  simcluster_energy_.clear();
  simcluster_pid_.clear();
  simcluster_detids_.clear();
  simcluster_bx_.clear();
  simcluster_ev_.clear();
  simcluster_px_.clear();
  simcluster_py_.clear();
  simcluster_pz_.clear();
  simcluster_idx_trackingparticle_.clear();
  simcluster_nhits_.clear();
 
  if (saveHits) {
    simhit_frac_.clear();
    simhit_x_.clear();
    simhit_y_.clear();
    simhit_z_.clear();
    simhit_det_.clear();
    simhit_subdet_.clear();
    simhit_eta_.clear();
    simhit_phi_.clear();
    simhit_idx_simcluster_.clear();
    simhit_detid_.clear();
 
    rechit_e_.clear();
    rechit_x_.clear();
    rechit_y_.clear();
    rechit_z_.clear();
    rechit_det_.clear();
    rechit_subdet_.clear();
    rechit_eta_.clear();
    rechit_phi_.clear();
    rechit_idx_element_.clear();
    rechit_detid_.clear();
  }
 
  simtrack_x_.clear();
  simtrack_y_.clear();
  simtrack_z_.clear();
  simtrack_idx_simcluster_.clear();
  simtrack_pid_.clear();
 
  gen_eta_.clear();
  gen_phi_.clear();
  gen_pt_.clear();
  gen_px_.clear();
  gen_py_.clear();
  gen_pz_.clear();
  gen_energy_.clear();
  gen_charge_.clear();
  gen_pdgid_.clear();
  gen_status_.clear();
  gen_daughters_.clear();
 
  element_pt_.clear();
  element_px_.clear();
  element_py_.clear();
  element_pz_.clear();
  element_deltap_.clear();
  element_sigmadeltap_.clear();
  element_eta_.clear();
  element_phi_.clear();
  element_energy_.clear();
  element_eta_ecal_.clear();
  element_phi_ecal_.clear();
  element_eta_hcal_.clear();
  element_phi_hcal_.clear();
  element_charge_.clear();
  element_type_.clear();
  element_layer_.clear();
  element_depth_.clear();
  element_trajpoint_.clear();
  element_muon_dt_hits_.clear();
  element_muon_csc_hits_.clear();
 
  element_distance_i_.clear();
  element_distance_j_.clear();
  element_distance_d_.clear();
 
  pfcandidate_eta_.clear();
  pfcandidate_phi_.clear();
  pfcandidate_pt_.clear();
  pfcandidate_px_.clear();
  pfcandidate_py_.clear();
  pfcandidate_pz_.clear();
  pfcandidate_energy_.clear();
  pfcandidate_pdgid_.clear();
 
}  //clearVariables

endJob()

void PFAnalysis::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1129 of file PFAnalysisNtuplizer.cc.

{}

endRun()

void PFAnalysis::endRun ( edm::Run const &  iEvent, edm::EventSetup const &    )

override

Definition at line 1125 of file PFAnalysisNtuplizer.cc.

{}

fillDescriptions()

void PFAnalysis::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 1131 of file PFAnalysisNtuplizer.cc.

                                                                            {
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

getHitPosition()

GlobalPoint PFAnalysis::getHitPosition ( const DetId &  id )

private

Definition at line 544 of file PFAnalysisNtuplizer.cc.

                                                      {
  GlobalPoint ret;
 
  bool present = false;
  if (((id.det() == DetId::Ecal &&
        (id.subdetId() == EcalBarrel || id.subdetId() == EcalEndcap || id.subdetId() == EcalPreshower)) ||
       (id.det() == DetId::Hcal && (id.subdetId() == HcalBarrel || id.subdetId() == HcalEndcap ||
                                    id.subdetId() == HcalForward || id.subdetId() == HcalOuter)))) {
    const CaloSubdetectorGeometry* geom_sd(geom->getSubdetectorGeometry(id.det(), id.subdetId()));
    present = geom_sd->present(id);
    if (present) {
      const auto& cell = geom_sd->getGeometry(id);
      ret = GlobalPoint(cell->getPosition());
    }
  }
  return ret;
}

References DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, relativeConstraints::geom, CaloSubdetectorGeometry::getGeometry(), DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, CaloSubdetectorGeometry::present(), and runTheMatrix::ret.

processBlocks()

pair< vector< ElementWithIndex >, vector< tuple< int, int, float > > > PFAnalysis::processBlocks ( const std::vector< reco::PFBlock > &  pfBlocks )

private

Definition at line 966 of file PFAnalysisNtuplizer.cc.

                                            {
  vector<ElementWithIndex> ret;
  vector<tuple<int, int, float>> distances;
 
  //Collect all the elements
  int iblock = 0;
  for (const auto& block : pfBlocks) {
    int ielem = 0;
    const auto& linkdata = block.linkData();
 
    //create a list of global element indices with distances
    for (const auto& link : linkdata) {
      const auto vecidx = link.first;
      const auto dist = link.second.distance;
      const auto& ij = get_triu_vector_index(vecidx, block.elements().size());
      auto globalindex_i = ij.first + ret.size();
      auto globalindex_j = ij.second + ret.size();
      distances.push_back(make_tuple(globalindex_i, globalindex_j, dist));
    }
 
    for (const auto& elem : block.elements()) {
      ElementWithIndex elem_index(elem, iblock, ielem);
      ret.push_back(elem_index);
      ielem += 1;
    }  //elements
    iblock += 1;
  }  //blocks
  return make_pair(ret, distances);
 
}  //processBlocks

References groupFilesInBlocks::block, get_triu_vector_index(), MainPageGenerator::link, and runTheMatrix::ret.

processTrackingParticles()

void PFAnalysis::processTrackingParticles ( const edm::View< TrackingParticle > &  trackingParticles, edm::Handle< edm::View< TrackingParticle >> &  trackingParticlesHandle  )

private

Definition at line 919 of file PFAnalysisNtuplizer.cc.

                                                                                                         {
  for (unsigned long ntrackingparticle = 0; ntrackingparticle < trackingParticles.size(); ntrackingparticle++) {
    const auto& tp = trackingParticles.at(ntrackingparticle);
    edm::RefToBase<TrackingParticle> tpref(trackingParticlesHandle, ntrackingparticle);
 
    math::XYZTLorentzVectorD vtx(0, 0, 0, 0);
 
    if (!tp.decayVertices().empty()) {
      vtx = tp.decayVertices().at(0)->position();
    }
    auto orig_vtx = tp.vertex();
 
    // fill branches
    trackingparticle_eta_.push_back(tp.p4().eta());
    trackingparticle_phi_.push_back(tp.p4().phi());
    trackingparticle_pt_.push_back(tp.p4().pt());
    trackingparticle_px_.push_back(tp.p4().px());
    trackingparticle_py_.push_back(tp.p4().py());
    trackingparticle_pz_.push_back(tp.p4().pz());
    trackingparticle_energy_.push_back(tp.p4().energy());
    trackingparticle_dvx_.push_back(vtx.x());
    trackingparticle_dvy_.push_back(vtx.y());
    trackingparticle_dvz_.push_back(vtx.z());
    trackingparticle_bx_.push_back(tp.eventId().bunchCrossing());
    trackingparticle_ev_.push_back(tp.eventId().event());
 
    trackingparticle_ovx_.push_back(orig_vtx.x());
    trackingparticle_ovy_.push_back(orig_vtx.y());
    trackingparticle_ovz_.push_back(orig_vtx.z());
 
    trackingparticle_pid_.push_back(tp.pdgId());
  }
}

References cmsswSequenceInfo::tp, muonClassificationByHits_cfi::trackingParticles, and extraflags_cff::vtx.

Member Data Documentation

aField_

MagneticField const* PFAnalysis::aField_

private

Definition at line 266 of file PFAnalysisNtuplizer.cc.

caloParticles_

edm::EDGetTokenT<edm::View<CaloParticle> > PFAnalysis::caloParticles_

private

Definition at line 140 of file PFAnalysisNtuplizer.cc.

element_charge_

vector<int> PFAnalysis::element_charge_

private

Definition at line 239 of file PFAnalysisNtuplizer.cc.

element_deltap_

vector<float> PFAnalysis::element_deltap_

private

Definition at line 230 of file PFAnalysisNtuplizer.cc.

element_depth_

vector<float> PFAnalysis::element_depth_

private

Definition at line 242 of file PFAnalysisNtuplizer.cc.

element_distance_d_

vector<float> PFAnalysis::element_distance_d_

private

Definition at line 249 of file PFAnalysisNtuplizer.cc.

element_distance_i_

vector<int> PFAnalysis::element_distance_i_

private

Definition at line 247 of file PFAnalysisNtuplizer.cc.

element_distance_j_

vector<int> PFAnalysis::element_distance_j_

private

Definition at line 248 of file PFAnalysisNtuplizer.cc.

element_energy_

vector<float> PFAnalysis::element_energy_

private

Definition at line 234 of file PFAnalysisNtuplizer.cc.

element_eta_

vector<float> PFAnalysis::element_eta_

private

Definition at line 232 of file PFAnalysisNtuplizer.cc.

element_eta_ecal_

vector<float> PFAnalysis::element_eta_ecal_

private

Definition at line 235 of file PFAnalysisNtuplizer.cc.

element_eta_hcal_

vector<float> PFAnalysis::element_eta_hcal_

private

Definition at line 237 of file PFAnalysisNtuplizer.cc.

element_layer_

vector<int> PFAnalysis::element_layer_

private

Definition at line 241 of file PFAnalysisNtuplizer.cc.

element_muon_csc_hits_

vector<float> PFAnalysis::element_muon_csc_hits_

private

Definition at line 245 of file PFAnalysisNtuplizer.cc.

element_muon_dt_hits_

vector<float> PFAnalysis::element_muon_dt_hits_

private

Definition at line 244 of file PFAnalysisNtuplizer.cc.

element_phi_

vector<float> PFAnalysis::element_phi_

private

Definition at line 233 of file PFAnalysisNtuplizer.cc.

element_phi_ecal_

vector<float> PFAnalysis::element_phi_ecal_

private

Definition at line 236 of file PFAnalysisNtuplizer.cc.

element_phi_hcal_

vector<float> PFAnalysis::element_phi_hcal_

private

Definition at line 238 of file PFAnalysisNtuplizer.cc.

element_pt_

vector<float> PFAnalysis::element_pt_

private

Definition at line 226 of file PFAnalysisNtuplizer.cc.

element_px_

vector<float> PFAnalysis::element_px_

private

Definition at line 227 of file PFAnalysisNtuplizer.cc.

element_py_

vector<float> PFAnalysis::element_py_

private

Definition at line 228 of file PFAnalysisNtuplizer.cc.

element_pz_

vector<float> PFAnalysis::element_pz_

private

Definition at line 229 of file PFAnalysisNtuplizer.cc.

element_sigmadeltap_

vector<float> PFAnalysis::element_sigmadeltap_

private

Definition at line 231 of file PFAnalysisNtuplizer.cc.

element_to_candidate

vector<pair<int, int> > PFAnalysis::element_to_candidate

private

Definition at line 263 of file PFAnalysisNtuplizer.cc.

element_trajpoint_

vector<float> PFAnalysis::element_trajpoint_

private

Definition at line 243 of file PFAnalysisNtuplizer.cc.

element_type_

vector<int> PFAnalysis::element_type_

private

Definition at line 240 of file PFAnalysisNtuplizer.cc.

ev_event_

edm::EventNumber_t PFAnalysis::ev_event_

private

Definition at line 150 of file PFAnalysisNtuplizer.cc.

ev_lumi_

edm::LuminosityBlockNumber_t PFAnalysis::ev_lumi_

private

Definition at line 149 of file PFAnalysisNtuplizer.cc.

ev_run_

edm::RunNumber_t PFAnalysis::ev_run_

private

Definition at line 148 of file PFAnalysisNtuplizer.cc.

gen_charge_

vector<int> PFAnalysis::gen_charge_

private

Definition at line 221 of file PFAnalysisNtuplizer.cc.

gen_daughters_

vector<vector<int> > PFAnalysis::gen_daughters_

private

Definition at line 224 of file PFAnalysisNtuplizer.cc.

gen_energy_

vector<float> PFAnalysis::gen_energy_

private

Definition at line 220 of file PFAnalysisNtuplizer.cc.

gen_eta_

vector<float> PFAnalysis::gen_eta_

private

Definition at line 214 of file PFAnalysisNtuplizer.cc.

gen_pdgid_

vector<int> PFAnalysis::gen_pdgid_

private

Definition at line 222 of file PFAnalysisNtuplizer.cc.

gen_phi_

vector<float> PFAnalysis::gen_phi_

private

Definition at line 215 of file PFAnalysisNtuplizer.cc.

gen_pt_

vector<float> PFAnalysis::gen_pt_

private

Definition at line 216 of file PFAnalysisNtuplizer.cc.

gen_px_

vector<float> PFAnalysis::gen_px_

private

Definition at line 217 of file PFAnalysisNtuplizer.cc.

gen_py_

vector<float> PFAnalysis::gen_py_

private

Definition at line 218 of file PFAnalysisNtuplizer.cc.

gen_pz_

vector<float> PFAnalysis::gen_pz_

private

Definition at line 219 of file PFAnalysisNtuplizer.cc.

gen_status_

vector<int> PFAnalysis::gen_status_

private

Definition at line 223 of file PFAnalysisNtuplizer.cc.

genParticles_

edm::EDGetTokenT<std::vector<reco::GenParticle> > PFAnalysis::genParticles_

private

Definition at line 138 of file PFAnalysisNtuplizer.cc.

geom

CaloGeometry* PFAnalysis::geom

private

Definition at line 273 of file PFAnalysisNtuplizer.cc.

geometryToken_

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> PFAnalysis::geometryToken_

private

Definition at line 268 of file PFAnalysisNtuplizer.cc.

hcal_topo

HcalTopology* PFAnalysis::hcal_topo

private

Definition at line 274 of file PFAnalysisNtuplizer.cc.

hcalDDDrecToken_

edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> PFAnalysis::hcalDDDrecToken_

private

Definition at line 271 of file PFAnalysisNtuplizer.cc.

hcons

const HcalDDDRecConstants* PFAnalysis::hcons

private

Definition at line 275 of file PFAnalysisNtuplizer.cc.

magFieldToken_

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> PFAnalysis::magFieldToken_

private

Definition at line 270 of file PFAnalysisNtuplizer.cc.

pfBlocks_

edm::EDGetTokenT<std::vector<reco::PFBlock> > PFAnalysis::pfBlocks_

private

Definition at line 142 of file PFAnalysisNtuplizer.cc.

pfcandidate_energy_

vector<float> PFAnalysis::pfcandidate_energy_

private

Definition at line 257 of file PFAnalysisNtuplizer.cc.

pfcandidate_eta_

vector<float> PFAnalysis::pfcandidate_eta_

private

Definition at line 251 of file PFAnalysisNtuplizer.cc.

pfcandidate_pdgid_

vector<int> PFAnalysis::pfcandidate_pdgid_

private

Definition at line 258 of file PFAnalysisNtuplizer.cc.

pfcandidate_phi_

vector<float> PFAnalysis::pfcandidate_phi_

private

Definition at line 252 of file PFAnalysisNtuplizer.cc.

pfcandidate_pt_

vector<float> PFAnalysis::pfcandidate_pt_

private

Definition at line 253 of file PFAnalysisNtuplizer.cc.

pfcandidate_px_

vector<float> PFAnalysis::pfcandidate_px_

private

Definition at line 254 of file PFAnalysisNtuplizer.cc.

pfcandidate_py_

vector<float> PFAnalysis::pfcandidate_py_

private

Definition at line 255 of file PFAnalysisNtuplizer.cc.

pfcandidate_pz_

vector<float> PFAnalysis::pfcandidate_pz_

private

Definition at line 256 of file PFAnalysisNtuplizer.cc.

pfCandidates_

edm::EDGetTokenT<std::vector<reco::PFCandidate> > PFAnalysis::pfCandidates_

private

Definition at line 143 of file PFAnalysisNtuplizer.cc.

rechit_det_

vector<float> PFAnalysis::rechit_det_

private

Definition at line 201 of file PFAnalysisNtuplizer.cc.

rechit_detid_

vector<uint64_t> PFAnalysis::rechit_detid_

private

Definition at line 206 of file PFAnalysisNtuplizer.cc.

rechit_e_

vector<float> PFAnalysis::rechit_e_

private

Definition at line 197 of file PFAnalysisNtuplizer.cc.

rechit_eta_

vector<float> PFAnalysis::rechit_eta_

private

Definition at line 203 of file PFAnalysisNtuplizer.cc.

rechit_idx_element_

vector<int> PFAnalysis::rechit_idx_element_

private

Definition at line 205 of file PFAnalysisNtuplizer.cc.

rechit_phi_

vector<float> PFAnalysis::rechit_phi_

private

Definition at line 204 of file PFAnalysisNtuplizer.cc.

rechit_subdet_

vector<float> PFAnalysis::rechit_subdet_

private

Definition at line 202 of file PFAnalysisNtuplizer.cc.

rechit_x_

vector<float> PFAnalysis::rechit_x_

private

Definition at line 198 of file PFAnalysisNtuplizer.cc.

rechit_y_

vector<float> PFAnalysis::rechit_y_

private

Definition at line 199 of file PFAnalysisNtuplizer.cc.

rechit_z_

vector<float> PFAnalysis::rechit_z_

private

Definition at line 200 of file PFAnalysisNtuplizer.cc.

saveHits

bool PFAnalysis::saveHits

private

Definition at line 277 of file PFAnalysisNtuplizer.cc.

simcluster_bx_

vector<int> PFAnalysis::simcluster_bx_

private

Definition at line 179 of file PFAnalysisNtuplizer.cc.

simcluster_detids_

vector<std::map<uint64_t, double> > PFAnalysis::simcluster_detids_

private

Definition at line 184 of file PFAnalysisNtuplizer.cc.

simcluster_energy_

vector<float> PFAnalysis::simcluster_energy_

private

Definition at line 175 of file PFAnalysisNtuplizer.cc.

simcluster_eta_

vector<float> PFAnalysis::simcluster_eta_

private

Definition at line 172 of file PFAnalysisNtuplizer.cc.

simcluster_ev_

vector<int> PFAnalysis::simcluster_ev_

private

Definition at line 180 of file PFAnalysisNtuplizer.cc.

simcluster_idx_trackingparticle_

vector<int> PFAnalysis::simcluster_idx_trackingparticle_

private

Definition at line 182 of file PFAnalysisNtuplizer.cc.

simcluster_nhits_

vector<int> PFAnalysis::simcluster_nhits_

private

Definition at line 183 of file PFAnalysisNtuplizer.cc.

simcluster_phi_

vector<float> PFAnalysis::simcluster_phi_

private

Definition at line 173 of file PFAnalysisNtuplizer.cc.

simcluster_pid_

vector<int> PFAnalysis::simcluster_pid_

private

Definition at line 181 of file PFAnalysisNtuplizer.cc.

simcluster_pt_

vector<float> PFAnalysis::simcluster_pt_

private

Definition at line 174 of file PFAnalysisNtuplizer.cc.

simcluster_px_

vector<float> PFAnalysis::simcluster_px_

private

Definition at line 176 of file PFAnalysisNtuplizer.cc.

simcluster_py_

vector<float> PFAnalysis::simcluster_py_

private

Definition at line 177 of file PFAnalysisNtuplizer.cc.

simcluster_pz_

vector<float> PFAnalysis::simcluster_pz_

private

Definition at line 178 of file PFAnalysisNtuplizer.cc.

simcluster_to_element

vector<pair<int, int> > PFAnalysis::simcluster_to_element

private

Definition at line 261 of file PFAnalysisNtuplizer.cc.

simcluster_to_element_cmp

vector<float> PFAnalysis::simcluster_to_element_cmp

private

Definition at line 262 of file PFAnalysisNtuplizer.cc.

simhit_det_

vector<int> PFAnalysis::simhit_det_

private

Definition at line 192 of file PFAnalysisNtuplizer.cc.

simhit_detid_

vector<uint64_t> PFAnalysis::simhit_detid_

private

Definition at line 195 of file PFAnalysisNtuplizer.cc.

simhit_eta_

vector<float> PFAnalysis::simhit_eta_

private

Definition at line 190 of file PFAnalysisNtuplizer.cc.

simhit_frac_

vector<float> PFAnalysis::simhit_frac_

private

Definition at line 186 of file PFAnalysisNtuplizer.cc.

simhit_idx_simcluster_

vector<int> PFAnalysis::simhit_idx_simcluster_

private

Definition at line 194 of file PFAnalysisNtuplizer.cc.

simhit_phi_

vector<float> PFAnalysis::simhit_phi_

private

Definition at line 191 of file PFAnalysisNtuplizer.cc.

simhit_subdet_

vector<int> PFAnalysis::simhit_subdet_

private

Definition at line 193 of file PFAnalysisNtuplizer.cc.

simhit_x_

vector<float> PFAnalysis::simhit_x_

private

Definition at line 187 of file PFAnalysisNtuplizer.cc.

simhit_y_

vector<float> PFAnalysis::simhit_y_

private

Definition at line 188 of file PFAnalysisNtuplizer.cc.

simhit_z_

vector<float> PFAnalysis::simhit_z_

private

Definition at line 189 of file PFAnalysisNtuplizer.cc.

simtrack_idx_simcluster_

vector<int> PFAnalysis::simtrack_idx_simcluster_

private

Definition at line 211 of file PFAnalysisNtuplizer.cc.

simtrack_pid_

vector<int> PFAnalysis::simtrack_pid_

private

Definition at line 212 of file PFAnalysisNtuplizer.cc.

simtrack_x_

vector<float> PFAnalysis::simtrack_x_

private

Definition at line 208 of file PFAnalysisNtuplizer.cc.

simtrack_y_

vector<float> PFAnalysis::simtrack_y_

private

Definition at line 209 of file PFAnalysisNtuplizer.cc.

simtrack_z_

vector<float> PFAnalysis::simtrack_z_

private

Definition at line 210 of file PFAnalysisNtuplizer.cc.

t_

TTree* PFAnalysis::t_

private

Definition at line 146 of file PFAnalysisNtuplizer.cc.

topologyToken_

edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> PFAnalysis::topologyToken_

private

Definition at line 269 of file PFAnalysisNtuplizer.cc.

trackingparticle_bx_

vector<int> PFAnalysis::trackingparticle_bx_

private

Definition at line 162 of file PFAnalysisNtuplizer.cc.

trackingparticle_dvx_

vector<float> PFAnalysis::trackingparticle_dvx_

private

Definition at line 159 of file PFAnalysisNtuplizer.cc.

trackingparticle_dvy_

vector<float> PFAnalysis::trackingparticle_dvy_

private

Definition at line 160 of file PFAnalysisNtuplizer.cc.

trackingparticle_dvz_

vector<float> PFAnalysis::trackingparticle_dvz_

private

Definition at line 161 of file PFAnalysisNtuplizer.cc.

trackingparticle_energy_

vector<float> PFAnalysis::trackingparticle_energy_

private

Definition at line 158 of file PFAnalysisNtuplizer.cc.

trackingparticle_eta_

vector<float> PFAnalysis::trackingparticle_eta_

private

Definition at line 152 of file PFAnalysisNtuplizer.cc.

trackingparticle_ev_

vector<int> PFAnalysis::trackingparticle_ev_

private

Definition at line 163 of file PFAnalysisNtuplizer.cc.

trackingparticle_exx_

vector<float> PFAnalysis::trackingparticle_exx_

private

Definition at line 167 of file PFAnalysisNtuplizer.cc.

trackingparticle_exy_

vector<float> PFAnalysis::trackingparticle_exy_

private

Definition at line 168 of file PFAnalysisNtuplizer.cc.

trackingparticle_mother_

vector<int> PFAnalysis::trackingparticle_mother_

private

Definition at line 169 of file PFAnalysisNtuplizer.cc.

trackingparticle_ovx_

vector<float> PFAnalysis::trackingparticle_ovx_

private

Definition at line 164 of file PFAnalysisNtuplizer.cc.

trackingparticle_ovy_

vector<float> PFAnalysis::trackingparticle_ovy_

private

Definition at line 165 of file PFAnalysisNtuplizer.cc.

trackingparticle_ovz_

vector<float> PFAnalysis::trackingparticle_ovz_

private

Definition at line 166 of file PFAnalysisNtuplizer.cc.

trackingparticle_phi_

vector<float> PFAnalysis::trackingparticle_phi_

private

Definition at line 153 of file PFAnalysisNtuplizer.cc.

trackingparticle_pid_

vector<int> PFAnalysis::trackingparticle_pid_

private

Definition at line 170 of file PFAnalysisNtuplizer.cc.

trackingparticle_pt_

vector<float> PFAnalysis::trackingparticle_pt_

private

Definition at line 154 of file PFAnalysisNtuplizer.cc.

trackingparticle_px_

vector<float> PFAnalysis::trackingparticle_px_

private

Definition at line 155 of file PFAnalysisNtuplizer.cc.

trackingparticle_py_

vector<float> PFAnalysis::trackingparticle_py_

private

Definition at line 156 of file PFAnalysisNtuplizer.cc.

trackingparticle_pz_

vector<float> PFAnalysis::trackingparticle_pz_

private

Definition at line 157 of file PFAnalysisNtuplizer.cc.

trackingparticle_to_element

vector<pair<int, int> > PFAnalysis::trackingparticle_to_element

private

Definition at line 260 of file PFAnalysisNtuplizer.cc.

trackingParticles_

edm::EDGetTokenT<edm::View<TrackingParticle> > PFAnalysis::trackingParticles_

private

Definition at line 139 of file PFAnalysisNtuplizer.cc.

tracks_

edm::EDGetTokenT<edm::View<reco::Track> > PFAnalysis::tracks_

private

Definition at line 141 of file PFAnalysisNtuplizer.cc.

tracks_recotosim_

edm::EDGetTokenT<reco::RecoToSimCollection> PFAnalysis::tracks_recotosim_

private

Definition at line 144 of file PFAnalysisNtuplizer.cc.